The CICA Windows Explosion!/The CICA Windows Explosion! - Disc 2.iso/demo/wemdemo3.zip/ETC/DOC

Text File | 1994-09-21 | 462KB | 10,698 lines

Fmake-abbrev-table
Create a new, empty abbrev table object.

arguments:()
Fclear-abbrev-table
Undefine all abbrevs in abbrev table TABLE, leaving it empty.

arguments:(table)
Fdefine-abbrev
Define an abbrev in TABLE named NAME, to expand to EXPANSION and call HOOK.
NAME and EXPANSION are strings.
To undefine an abbrev, define it with EXPANSION = nil.
If HOOK is non-nil, it should be a function of no arguments;
it is called after EXPANSION is inserted.

arguments:(table name expansion &optional hook count)
Fdefine-global-abbrev
Define ABBREV as a global abbreviation for EXPANSION.

arguments:(name expansion)
Fdefine-mode-abbrev
Define ABBREV as a mode-specific abbreviation for EXPANSION.

arguments:(name expansion)
Fabbrev-symbol
Return the symbol representing abbrev named ABBREV.
This symbol's name is ABBREV, but it is not the canonical symbol of that name;
it is interned in an abbrev-table rather than the normal obarray.
The value is nil if that abbrev is not defined.
Optional second arg TABLE is abbrev table to look it up in.
The default is to try buffer's mode-specific abbrev table, then global table.

arguments:(abbrev &optional table)
Fabbrev-expansion
Return the string that ABBREV expands into in the current buffer.
Optionally specify an abbrev table as second arg;
then ABBREV is looked up in that table only.

arguments:(abbrev &optional table)
Fexpand-abbrev
Expand the abbrev before point, if there is an abbrev there.
Effective when explicitly called even when `abbrev-mode' is nil.
Returns t if expansion took place.

arguments:()
Funexpand-abbrev
Undo the expansion of the last abbrev that expanded.
This differs from ordinary undo in that other editing done since then
is not undone.

arguments:()
Finsert-abbrev-table-description
Insert before point a full description of abbrev table named NAME.
NAME is a symbol whose value is an abbrev table.
If optional 2nd arg HUMAN is non-nil, a human-readable description is inserted.
Otherwise the description is an expression,
a call to `define-abbrev-table', which would
define the abbrev table NAME exactly as it is currently defined.

arguments:(name &optional readable)
Fdefine-abbrev-table
Define TABNAME (a symbol) as an abbrev table name.
Define abbrevs in it according to DEFINITIONS, which is a list of elements
of the form (ABBREVNAME EXPANSION HOOK USECOUNT).

arguments:(tabname defns)
Vabbrev-table-name-list
List of symbols whose values are abbrev tables.Vglobal-abbrev-table
The abbrev table whose abbrevs affect all buffers.
Each buffer may also have a local abbrev table.
If it does, the local table overrides the global one
for any particular abbrev defined in both.Vfundamental-mode-abbrev-table
The abbrev table of mode-specific abbrevs for Fundamental Mode.Vlast-abbrev
The abbrev-symbol of the last abbrev expanded.  See `abbrev-symbol'.Vlast-abbrev-text
The exact text of the last abbrev expanded.
nil if the abbrev has already been unexpanded.Vlast-abbrev-location
The location of the start of the last abbrev expanded.Vabbrev-start-location
Buffer position for `expand-abbrev' to use as the start of the abbrev.
nil means use the word before point as the abbrev.
Calling `expand-abbrev' sets this to nil.Vabbrev-start-location-buffer
Buffer that `abbrev-start-location' has been set for.
Trying to expand an abbrev in any other buffer clears `abbrev-start-location'.Vabbrevs-changed
Set non-nil by defining or altering any word abbrevs.
This causes `save-some-buffers' to offer to save the abbrevs.Vabbrev-all-caps
*Set non-nil means expand multi-word abbrevs all caps if abbrev was so.Vpre-abbrev-expand-hook
Function or functions to be called before abbrev expansion is done.
This is the first thing that `expand-abbrev' does, and so this may change
the current abbrev table before abbrev lookup happens.Fcons
Create a new cons, give it CAR and CDR as components, and return it.

arguments:(car cdr)
Flist
Return a newly created list with specified arguments as elements.
Any number of arguments, even zero arguments, are allowed.

arguments: (&rest args)
Fmake-list
Return a newly created list of length LENGTH, with each element being INIT.

arguments:(length init)
Fmake-vector
Return a newly created vector of length LENGTH, with each element being INIT.
See also the function `vector'.

arguments:(length init)
Fvector
Return a newly created vector with specified arguments as elements.
Any number of arguments, even zero arguments, are allowed.

arguments: (&rest args)
Fmake-byte-code
Create a byte-code object with specified arguments as elements.
At least four arguments are required; only six have any significance.

arguments: (arg1 arg2 arg3 arg4 &rest args)
Fmake-symbol
Return a newly allocated uninterned symbol whose name is NAME.
Its value and function definition are void, and its property list is nil.

arguments:(str)
Fmake-marker
Return a newly allocated marker which does not point at any place.

arguments:()
Fmake-string
Return a newly created string of length LENGTH, with each element being INIT.
Both LENGTH and INIT must be numbers.

arguments:(length init)
Fpurecopy
Make a copy of OBJECT in pure storage.
Recursively copies contents of vectors and cons cells.
Does not copy symbols.

arguments:(obj)
Fgarbage-collect
Reclaim storage for Lisp objects no longer needed.
Returns info on amount of space in use:
 ((USED-CONSES . FREE-CONSES) (USED-SYMS . FREE-SYMS)
  (USED-MARKERS . FREE-MARKERS) USED-STRING-CHARS USED-VECTOR-SLOTS
  (USED-FLOATS . FREE-FLOATS) (USED-EVENTS . FREE-EVENTS))
Garbage collection happens automatically if you cons more than
`gc-cons-threshold' bytes of Lisp data since previous garbage collection.

arguments:()
Vgc-cons-threshold
*Number of bytes of consing between garbage collections.
Garbage collection can happen automatically once this many bytes have been
allocated since the last garbage collection.  All data types count.

Garbage collection happens automatically when `eval' or `funcall' are
called.  (Note that `funcall' is called implicitly.)
By binding this temporarily to a large number, you can effectively
prevent garbage collection during a part of the program.Vpure-bytes-used
Number of bytes of sharable Lisp data allocated so far.Vdata-bytes-used
Number of bytes of unshared memory allocated in this session.Vdata-bytes-free
Number of bytes of unshared memory remaining available in this session.Vpurify-flag
Non-nil means loading Lisp code in order to dump an executable.
This means that certain objects should be allocated in shared (pure) space.Vundo-threshold
Keep no more undo information once it exceeds this size.
This threshold is applied when garbage collection happens.
The size is counted as the number of bytes occupied,
which includes both saved text and other data.Vundo-high-threshold
Don't keep more than this much size of undo information.
A command which pushes past this size is itself forgotten.
This threshold is applied when garbage collection happens.
The size is counted as the number of bytes occupied,
which includes both saved text and other data.V   gc-currently-forbidden
internal variable used to control undoFbuffer-list
Return a list of all existing live buffers.
The order is specific to the selected screen; if the optional SCREEN
argument is provided, the ordering for that screen is returned instead.
If the SCREEN argument is t, then the global (non-screen) ordering is
returned instead.

arguments:(&optional screen)
Fget-buffer
Return the buffer named NAME (a string).
If there is no live buffer named NAME, return nil.
NAME may also be a buffer; if so, the value is that buffer.

arguments:(name)
Fget-file-buffer
Return the buffer visiting file FILENAME (a string).
If there is no such live buffer, return nil.

arguments:(filename)
Fget-buffer-create
Return the buffer named NAME, or create such a buffer and return it.
A new buffer is created if there is no live buffer named NAME.
If NAME starts with a space, the new buffer does not keep undo information.
If NAME is a buffer instead of a string, then it is the value returned.
The value is never nil.

arguments:(name)
Fgenerate-new-buffer-name
Return a string that is the name of no existing buffer based on NAME.
If there is no live buffer named NAME, then return NAME.
Otherwise modify name by appending `<NUMBER>', incrementing NUMBER
until an unused name is found, and then return that name.

arguments:(name)
Fbuffer-name
Return the name of BUFFER, as a string.
With no argument or nil as argument, return the name of the current buffer.

arguments:(&optional buffer)
Fbuffer-file-name
Return name of file BUFFER is visiting, or nil if none.
No argument or nil as argument means use the current buffer.

arguments:(&optional buffer)
Fbuffer-local-variables
Return an alist of variables that are buffer-local in BUFFER.
Each element looks like (SYMBOL . VALUE) and describes one variable.
Note that storing new VALUEs in these elements doesn't change the variables.
No argument or nil as argument means use current buffer as BUFFER.

arguments:(&optional buffer)
Fbuffer-dedicated-screen
Return the screen dedicated to this BUFFER, or nil if there is none.
No argument or nil as argument means use current buffer as BUFFER.

arguments:(&optional buffer)
Fset-buffer-dedicated-screen
For this BUFFER, set the SCREEN dedicated to it.
SCREEN must be a screen or nil.

arguments:(buffer screen)
Fbuffer-modified-p
Return t if BUFFER was modified since its file was last read or saved.
No argument or nil as argument means use current buffer as BUFFER.

arguments:(&optional buffer)
Fset-buffer-modified-p
Mark current buffer as modified or unmodified according to FLAG.
A non-nil FLAG means mark the buffer modified.

arguments:(flag)
Fbuffer-modified-tick
Return BUFFER's tick counter, incremented for each change in text.
Each buffer has a tick counter which is incremented each time the text in
that buffer is changed.  It wraps around occasionally.
No argument or nil as argument means use current buffer as BUFFER.

arguments:(&optional buffer)
Frename-buffer
Change current buffer's name to NEWNAME (a string).
If second arg DISTINGUISH is nil or omitted, it is an error if a
buffer named NEWNAME already exists.
If DISTINGUISH is non-nil, come up with a new name using
`generate-new-buffer-name'.
Return the name we actually gave the buffer.
This does not change the name of the visited file (if any).

arguments:(name &optional distinguish)
Fother-buffer
Return most recently selected buffer other than BUFFER.
Buffers not visible in windows are preferred to visible buffers.
If no other buffer exists, the buffer `*scratch*' is returned.
If BUFFER is omitted or nil, some interesting buffer is returned.

The ordering is for this screen; If second optional argument SCREEN
is provided, then the ordering is for that screen.  If the second arg
is t, then the global ordering is returned.

arguments:(&optional buffer screen)
Fbuffer-disable-undo
Make BUFFER stop keeping undo information.
Any undo records it already has are discarded.

arguments:(buffer)
Fbuffer-enable-undo
Start keeping undo information for buffer BUFFER.
No argument or nil as argument means do this for the current buffer.

arguments:(&optional buffer)
Fkill-buffer
Kill the buffer BUFFER.
The argument may be a buffer or may be the name of a buffer.
An argument of nil means kill the current buffer.

Value is t if the buffer is actually killed, nil if user says no.

The value of `kill-buffer-hook' (which may be local to that buffer),
if not void, is a list of functions to be called, with no arguments,
before the buffer is actually killed.  The buffer to be killed is current
when the hook functions are called.

Any processes that have this buffer as the `process-buffer' are killed
with `delete-process'.

arguments:(bufname)
Fswitch-to-buffer
Select buffer BUFFER in the current window.
BUFFER may be a buffer or a buffer name.
Optional second arg NORECORD non-nil means
do not put this buffer at the front of the list of recently selected ones.

WARNING: This is NOT the way to work on another buffer temporarily
within a Lisp program!  Use `set-buffer' instead.  That avoids messing with
the window-buffer correspondences.

arguments:(bufname &optional norecord)
Fpop-to-buffer
Select buffer BUFFER in some window, preferably a different one.
If BUFFER is nil, then some other buffer is chosen.
If `pop-up-windows' is non-nil, windows can be split to do this.
If optional second arg WINDOW is non-nil, insist on finding another
window even if BUFFER is already visible in the selected window.
If optional third arg is non-nil, it is the screen to pop to this
buffer on.

arguments:(bufname &optional not_this_window_p on_screen)
Fcurrent-buffer
Return the current buffer as a Lisp object.

arguments:()
Fset-buffer
Make the buffer BUFFER current for editing operations.
BUFFER may be a buffer or the name of an existing buffer.
See also `save-excursion' when you want to make a buffer current temporarily.
This function does not display the buffer, so its effect ends
when the current command terminates.
Use `switch-to-buffer' or `pop-to-buffer' to switch buffers permanently.

arguments:(bufname)
Fbarf-if-buffer-read-only
Signal a `buffer-read-only' error if the current buffer is read-only.

arguments:()
Fbarf-if-buffer-read-only
Signal a `buffer-read-only' error if the buffer is read-only.
Optional argument BUFFER defaults to `(current-buffer)'
If optional arguments START and END are non-nil, all extents in the buffer
which overlap that part of the buffer are checked to ensure none has a
`read-only' property.  END defaults to the value of START.

arguments:(&optional buffer start end)
Fbury-buffer
Put BUFFER at the end of the list of all buffers.
There it is the least likely candidate for `other-buffer' to return;
thus, the least likely buffer for \[switch-to-buffer] to select by default.

arguments:(&optional buffer)
Ferase-buffer
Delete the entire contents of the current buffer.
Any clipping restriction in effect (see `narrow-to-buffer') is removed,
so the buffer is truly empty after this.

arguments:()
Fkill-all-local-variables
Switch to Fundamental mode by killing current buffer's local variables.
Most local variable bindings are eliminated so that the default values
become effective once more.  Also, the syntax table is set from
`standard-syntax-table', the local keymap is set to nil,
and the abbrev table from `fundamental-mode-abbrev-table'.
This function also forces redisplay of the mode line.

Every function to select a new major mode starts by
calling this function.

As a special exception, local variables whose names have
a non-nil `permanent-local' property are not eliminated by this function.

arguments:()
Fregion-fields
Return list of fields overlapping a given portion of a buffer.
The portion is specified by arguments START, END and BUFFER.
BUFFER defaults to the current buffer.
Optional 4th arg ERROR-CHECK non nil means just report an error
if any protected fields overlap this portion.

arguments:(start end &optional buffer error_check)
Vdefault-mode-line-format
Default value of `mode-line-format' for buffers that don't override it.
This is the same as (default-value 'mode-line-format).Vdefault-abbrev-mode
Default value of `abbrev-mode' for buffers that do not override it.
This is the same as (default-value 'abbrev-mode).Vdefault-ctl-arrow
Default value of `ctl-arrow' for buffers that do not override it.
This is the same as (default-value 'ctl-arrow).Vdefault-truncate-lines
Default value of `truncate-lines' for buffers that do not override it.
This is the same as (default-value 'truncate-lines).Vdefault-fill-column
Default value of `fill-column' for buffers that do not override it.
This is the same as (default-value 'fill-column).Vdefault-left-margin
Default value of `left-margin' for buffers that do not override it.
This is the same as (default-value 'left-margin).Vdefault-tab-width
Default value of `tab-width' for buffers that do not override it.
This is the same as (default-value 'tab-width).Vdefault-case-fold-search
Default value of `case-fold-search' for buffers that don't override it.
This is the same as (default-value 'case-fold-search).Vdefault-file-type
Default value of `file-type' for buffers that do not override it.
This is the same as (default-value 'file-type).Vmode-line-format
Template for displaying mode line for current buffer.
Each buffer has its own value of this variable.
Value may be a string, a symbol or a list or cons cell.
For a symbol, its value is used (but it is ignored if t or nil).
 A string appearing directly as the value of a symbol is processed verbatim
 in that the %-constructs below are not recognized.
For a list whose car is a symbol, the symbol's value is taken,
 and if that is non-nil, the cadr of the list is processed recursively.
 Otherwise, the caddr of the list (if there is one) is processed.
For a list whose car is a string or list, each element is processed
 recursively and the results are effectively concatenated.
For a list whose car is an integer, the cdr of the list is processed
  and padded (if the number is positive) or truncated (if negative)
  to the width specified by that number.
A string is printed verbatim in the mode line except for %-constructs:
  (%-constructs are allowed when the string is the entire mode-line-format
   or when it is found in a cons-cell or a list)
  %b -- print buffer name.      %f -- print visited file name.
  %* -- print *, % or hyphen.   %m -- print value of mode-name (obsolete).
  %s -- print process status.   %M -- print value of global-mode-string. (obs)
  %S -- print name of selected screen (only meaningful under X Windows).
  %p -- print percent of buffer above top of window, or top, bot or all.
  %n -- print Narrow if appropriate.
  %[ -- print one [ for each recursive editing level.  %] similar.
  %% -- print %.   %- -- print infinitely many dashes.
Decimal digits after the % specify field width to which to pad.Vdefault-major-mode
*Major mode for new buffers.  Defaults to `fundamental-mode'.
nil here means use current buffer's major mode.Vmajor-mode
Symbol for current buffer's major mode.Vmode-name
Pretty name of current buffer's major mode (a string).Vabbrev-mode
Non-nil turns on automatic expansion of abbrevs as they are inserted.
Automatically becomes buffer-local when set in any fashion.Vcase-fold-search
*Non-nil if searches should ignore case.
Automatically becomes buffer-local when set in any fashion.Vfill-column
*Column beyond which automatic line-wrapping should happen.
Automatically becomes buffer-local when set in any fashion.Vleft-margin
*Column for the default indent-line-function to indent to.
Linefeed indents to this column in Fundamental mode.
Automatically becomes buffer-local when set in any fashion.Vtab-width
*Distance between tab stops (for display of tab characters), in columns.
Automatically becomes buffer-local when set in any fashion.Vctl-arrow
*Non-nil means display control chars with uparrow.
Nil means use backslash and octal digits.
An integer means characters >= ctl-arrow are assumed to be printable, and
will be displayed as a single glyph.
Any other value is the same as 160 - the code SPC with the high bit on.

The interpretation of this variable is likely to change in the future.

Automatically becomes buffer-local when set in any fashion.
This variable does not apply to characters whose display is specified
in the current display table (if there is one).Vtruncate-lines
*Non-nil means do not display continuation lines;
give each line of text one screen line.
Automatically becomes buffer-local when set in any fashion.

Note that this is overridden by the variable
`truncate-partial-width-windows' if that variable is non-nil
and this buffer is not full-screen width.Vfile-type
*File-type for file and process input/output.Vdefault-directory
Name of default directory of current buffer.  Should end with slash.
Each buffer has its own value of this variable.Vauto-fill-function
Function called (if non-nil) to perform auto-fill.
It is called after self-inserting a space at a column beyond `fill-column'.
Each buffer has its own value of this variable.
NOTE: This variable is not an ordinary hook;
It may not be a list of functions.Vbuffer-file-name
Name of file visited in current buffer, or nil if not visiting a file.
Each buffer has its own value of this variable.Vbuffer-file-truename
The real name of the file visited in the current buffer,
or nil if not visiting a file.  This is the result of passing
buffer-file-name to the `truename' function.  Every buffer has
its own value of this variable.  This variable is automatically
maintained by the functions that change the file name associated
with a buffer.Vbuffer-auto-save-file-name
Name of file for auto-saving current buffer,
or nil if buffer should not be auto-saved.
Each buffer has its own value of this variable.Vbuffer-read-only
Non-nil if this buffer is read-only.
Each buffer has its own value of this variable.Vbuffer-backed-up
Non-nil if this buffer's file has been backed up.
Backing up is done before the first time the file is saved.
Each buffer has its own value of this variable.Vbuffer-saved-size
Length of current buffer when last read in, saved or auto-saved.
0 initially.
Each buffer has its own value of this variable.Vselective-display
Non-nil enables selective display:
Integer N as value means display only lines
 that start with less than n columns of space.
A value of t means, after a ^M, all the rest of the line is invisible.
 Then ^M's in the file are written into files as newlines.

Automatically becomes buffer-local when set in any fashion.Vlocal-abbrev-table
Local (mode-specific) abbrev table of current buffer.Vselective-display-ellipses
t means display ... on previous line when a line is invisible.
Automatically becomes buffer-local when set in any fashion.Voverwrite-mode
Non-nil if self-insertion should replace existing text.
Automatically becomes buffer-local when set in any fashion.Vbuffer-display-table
Display table that controls display of the contents of current buffer.
Automatically becomes buffer-local when set in any fashion.
The display table is a vector created with `make-display-table'.
The first 256 elements control how to display each possible text character.
The value should be a "rope" (see `make-rope') or nil;
nil means display the character in the default fashion.
The remaining five elements are ropes that control the display of
  the end of a truncated screen line (element 256);
  the end of a continued line (element 257);
  the escape character used to display character codes in octal (element 258);
  the character used as an arrow for control characters (element 259);
  the decoration indicating the presence of invisible lines (element 260).
If this variable is nil, the value of `standard-display-table' is used.
Each window can have its own, overriding display table.Vbuffer-field-list
List of fields in the current buffer.  See `add-field'.Vfind-file-compare-truenames
If this is true, then the find-file command will check the truenames
of all visited files when deciding whether a given file is already in
a buffer, instead of just the buffer-file-name.  This means that if you
attempt to visit another file which is a symbolic-link to a file which is
already in a buffer, the existing buffer will be found instead of a newly-
created one.  This works if some non-terminal component of the pathname is
a symbolic link as well, but doesn't work with hard links (nothing does.)

See also the variable find-file-use-truenames.Vfind-file-use-truenames
If this is true, then a buffer's visited file-name will always be
chased back to the real file; it will never be a symbolic link, and there
will never be a symbolic link anywhere in its directory path.
That is, the buffer-file-name and buffer-file-truename will be equal.
This doesn't work with hard links.

See also the variable find-file-compare-truenames.Vbefore-change-function
Function to call before each text change.
Two arguments are passed to the function: the positions of
the beginning and end of the range of old text to be changed.
For an insertion, the beginning and end are at the same place.
No information is given about the length of the text after the change.
position of the change

While executing the `before-change-function', changes to buffers do not
cause calls to any `before-change-function' or `after-change-function'.Vafter-change-function
Function to call after each text change.
Three arguments are passed to the function: the positions of
the beginning and end of the range of changed text,
and the length of the pre-change text replaced by that range.
For an insertion, the pre-change length is zero;
for a deletion, that length is the number of characters deleted,
and the post-change beginning and end are at the same place.

While executing the `after-change-function', changes to buffers do not
cause calls to any `before-change-function' or `after-change-function'.Vfirst-change-function
Function to call before changing a buffer which is unmodified.
The function is called, with no arguments, if it is non-nil.Vbuffer-undo-list
List of undo entries in current buffer.Fbyte-code
Function used internally in byte-compiled code.
The first argument is a string of byte code; the second, a vector of constants;
the third, the maximum stack depth used in this function.
If the third argument is incorrect, Emacs may crash.

arguments:(bytestr vector maxdepth)
Vbyte-code-meter
A vector of vectors which holds a histogram of byte-code usage.Vbyte-metering-on
Finteractive
Specify a way of parsing arguments for interactive use of a function.
For example, write
  (defun foo (arg) "Doc string" (interactive "p") ...use arg...)
to make ARG be the prefix argument when `foo' is called as a command.
The "call" to `interactive' is actually a declaration rather than a function;
 it tells `call-interactively' how to read arguments
 to pass to the function.
When actually called, `interactive' just returns nil.

The argument of `interactive' is usually a string containing a code letter
 followed by a prompt.  (Some code letters do not use I/O to get
 the argument and do not need prompts.)  To prompt for multiple arguments,
 give a code letter, its prompt, a newline, and another code letter, etc.
 Prompts are passed to format, and may use % escapes to print the
 arguments that have already been read.
If the argument is not a string, it is evaluated to get a list of
 arguments to pass to the function.
Just `(interactive)' means pass no args when calling interactively.

Code letters available are:
a -- Function name: symbol with a function definition.
b -- Name of existing buffer.
B -- Name of buffer, possibly nonexistent.
c -- Character.
C -- Command name: symbol with interactive function definition.
d -- Value of point as number.  Does not do I/O.
D -- Directory name.
e -- Last mouse event.
f -- Existing file name.
F -- Possibly nonexistent file name.
k -- Key sequence (a vector of events).
m -- Value of mark as number.  Does not do I/O.
n -- Number read using minibuffer.
N -- Prefix arg converted to number, or if none, do like code `n'.
p -- Prefix arg converted to number.  Does not do I/O.
P -- Prefix arg in raw form.  Does not do I/O.
r -- Region: point and mark as 2 numeric args, smallest first.  Does no I/O.
s -- Any string.
S -- Any symbol.
v -- Variable name: symbol that is user-variable-p.
x -- Lisp expression read but not evaluated.
X -- Lisp expression read and evaluated.
In addition, if the string begins with `*'
 then an error is signaled if the buffer is read-only.
 This happens before reading any arguments.
If the string begins with `@', then the window the mouse is over is selected
 before anything else is done.  You may use both `@' and `*';
they are processed in the order that they appear.

arguments:(args)
Fcall-interactively
Call FUNCTION, reading args according to its interactive calling specs.
The function contains a specification of how to do the argument reading.
In the case of user-defined functions, this is specified by placing a call
to the function `interactive' at the top level of the function body.
See `interactive'.

If optional second arg RECORD-FLAG is `t' then unconditionally put this
ommand in the command-history.  Otherwise, this is done only if an arg is
read using the minibuffer.

arguments:(function &optional record_flag)
Fprefix-numeric-value
Return numeric meaning of raw prefix argument ARG.
A raw prefix argument is what you get from `(interactive "P")'.
Its numeric meaning is what you would get from `(interactive "p")'.

arguments:(raw)
Vprefix-arg
The value of the prefix argument for the next editing command.
It may be a number, or the symbol `-' for just a minus sign as arg,
or a list whose car is a number for just one or more C-U's
or nil if no argument has been specified.

You cannot examine this variable to find the argument for this command
since it has been set to nil by the time you can look.
Instead, you should use the variable `current-prefix-arg', although
normally commands can get this prefix argument with (interactive "P").Vcurrent-prefix-arg
The value of the prefix argument for this editing command.
It may be a number, or the symbol `-' for just a minus sign as arg,
or a list whose car is a number for just one or more C-U's
or nil if no argument has been specified.
This is what `(interactive "P")' returns.Vcurrent-mouse-event
The mouse-button event which invoked this command, or nil.
This is what `(interactive "e")' returns.Vcommand-history
List of recent commands that read arguments from terminal.
Each command is represented as a form to evaluate.Vcommand-debug-status
Debugging status of current interactive command.
Bound each time `call-interactively' is called;
may be set by the debugger as a reminder for itself.Fcall-process
Call PROGRAM synchronously in separate process.
The program's input comes from file INFILE (nil means `/dev/null', or
the `nul' device under MS-DOS).
Insert output in BUFFER before point; t means current buffer;
 nil for BUFFER means discard it; 0 means discard and don't wait.
Fourth arg DISPLAY non-nil means redisplay buffer as output is inserted.
Remaining arguments are strings passed as command arguments to PROGRAM.
If BUFFER is nil or 0, returns immediately with value nil.
Otherwise waits for PROGRAM to terminate
and returns a numeric exit status or a signal name as a string.
If you quit, the process is killed with SIGKILL.

arguments: (arg1 &rest args)
Fcall-process-region
Send text from START to END to a synchronous process running PROGRAM.
Delete the text if fourth arg DELETE is non-nil.
Insert output in BUFFER before point; t means current buffer;
 nil for BUFFER means discard it; 0 means discard and don't wait.
Sixth arg DISPLAY non-nil means redisplay buffer as output is inserted.
Remaining args are passed to PROGRAM at startup as command args.
If BUFFER is nil, returns immediately with value nil.
Otherwise waits for PROGRAM to terminate
and returns a numeric exit status or a signal name as a string.
If you quit, the process is killed with SIGKILL.

arguments: (arg1 arg2 arg3 &rest args)
Vshell-file-name
*File name to load inferior shells from.
Initialized from the SHELL environment variable.
Under MS-DOS, initialized from the COMSPEC environment variable
if SHELL is not set.Vexec-path
*List of directories to search programs to run in subprocesses.
Each element is a string (directory name) or nil (try default directory).Vexec-directory
Directory that holds programs that come with GNU Emacs,
intended for Emacs to invoke.Vprocess-environment
List of strings to append to environment of subprocesses that are started.
Each string should have the format ENVVARNAME=VALUE.Fupcase
Convert argument to upper case and return that.
The argument may be a character or string.  The result has the same type.
The argument object is not altered.  See also `capitalize'.

arguments:(obj)
Fdowncase
Convert argument to lower case and return that.
The argument may be a character or string.  The result has the same type.
The argument object is not altered.

arguments:(obj)
Fcapitalize
Convert argument to capitalized form and return that.
This means that each word's first character is upper case
and the rest is lower case.
The argument may be a character or string.  The result has the same type.
The argument object is not altered.

arguments:(obj)
Fupcase-region
Convert the region to upper case.  In programs, wants two arguments.
These arguments specify the starting and ending character numbers of
the region to operate on.  When used as a command, the text between
point and the mark is operated on.
See also `capitalize-region'.

arguments:(b e)
Fdowncase-region
Convert the region to lower case.  In programs, wants two arguments.
These arguments specify the starting and ending character numbers of
the region to operate on.  When used as a command, the text between
point and the mark is operated on.

arguments:(b e)
Fcapitalize-region
Convert the region to capitalized form.
Capitalized form means each word's first character is upper case
and the rest of it is lower case.
In programs, give two arguments, the starting and ending
character positions to operate on.

arguments:(b e)
Fupcase-word
Convert following word (or ARG words) to upper case, moving over.
With negative argument, convert previous words but do not move.
See also `capitalize-word'.

arguments:(arg)
Fdowncase-word
Convert following word (or ARG words) to lower case, moving over.
With negative argument, convert previous words but do not move.

arguments:(arg)
Fcapitalize-word
Capitalize the following word (or ARG words), moving over.
This gives the word(s) a first character in upper case
and the rest lower case.
With negative argument, capitalize previous words but do not move.

arguments:(arg)
Fcase-table-p
Return t iff ARG is a case table.
See `set-case-table' for more information on these data structures.

arguments:(table)
Fcurrent-case-table
Return the case table of the current buffer.

arguments:()
Fstandard-case-table
Return the standard case table.
This is the one used for new buffers.

arguments:()
Fset-case-table
Select a new case table for the current buffer.
A case table is a list (DOWNCASE UPCASE CANONICALIZE EQUIVALENCES)
 where each element is either nil or a string of length 256.
DOWNCASE maps each character to its lower-case equivalent.
UPCASE maps each character to its upper-case equivalent;
 if lower and upper case characters are in 1-1 correspondence,
 you may use nil and the upcase table will be deduced from DOWNCASE.
CANONICALIZE maps each character to a canonical equivalent;
 any two characters that are related by case-conversion have the same
 canonical equivalent character.
EQUIVALENCES is a map that cyclicly permutes each equivalence class
 (of characters with the same canonical equivalent).
Both CANONICALIZE and EQUIVALENCES may be nil, in which case
 both are deduced from DOWNCASE and UPCASE.

arguments:(table)
Fset-standard-case-table
Select a new standard case table for new buffers.
See `set-case-table' for more info on case tables.

arguments:(table)
Vascii-downcase-table
String mapping ASCII characters to lowercase equivalents.Vascii-upcase-table
String mapping ASCII characters to uppercase equivalents.Fforward-char
Move point right ARG characters (left if ARG negative).
On reaching end of buffer, stop and signal error.

arguments:(&optional n)
Fbackward-char
Move point left ARG characters (right if ARG negative).
On attempt to pass beginning or end of buffer, stop and signal error.

arguments:(&optional n)
Fforward-line
Move ARG lines forward (backward if ARG is negative).
Precisely, if point is on line I, move to the start of line I + ARG.
If there isn't room, go as far as possible (no error).
Returns the count of lines left to move.  If moving forward,
that is ARG - number of lines moved; if backward, ARG + number moved.
With positive ARG, a non-empty line at the end counts as one line
  successfully moved (for the return value).

arguments:(&optional n)
Fbeginning-of-line
Move point to beginning of current line.
With argument ARG not nil or 1, move forward ARG - 1 lines first.
If scan reaches end of buffer, stop there without error.

arguments:(&optional n)
Fend-of-line
Move point to end of current line.
With argument ARG not nil or 1, move forward ARG - 1 lines first.
If scan reaches end of buffer, stop there without error.

arguments:(&optional n)
Fdelete-char
Delete the following ARG characters (previous, with negative arg).
Optional second arg KILLFLAG non-nil means kill instead (save in kill ring).
Interactively, ARG is the prefix arg, and KILLFLAG is set if
ARG was explicitly specified.

arguments:(n &optional killflag)
Fdelete-backward-char
Delete the previous ARG characters (following, with negative ARG).
Optional second arg KILLFLAG non-nil means kill instead (save in kill ring).
Interactively, ARG is the prefix arg, and KILLFLAG is set if
ARG was explicitly specified.

arguments:(n &optional killflag)
Fself-insert-command
Insert the character you type.
Whichever character you type to run this command is inserted.

arguments:(arg)
Fnewline
Insert a newline.  With arg, insert that many newlines.
In Auto Fill mode, if no numeric arg, break the preceding line if it's long.

arguments:(&optional arg1)
Vblink-paren-function
Function called, if non-nil, whenever a close parenthesis is inserted.
More precisely, a char with closeparen syntax is self-inserted.Feq
T if the two args are the same Lisp object.

arguments:(obj1 obj2)
Fnull
T if OBJECT is nil.

arguments:(obj)
Fconsp
T if OBJECT is a cons cell.

arguments:(obj)
Fatom
T if OBJECT is not a cons cell.  This includes nil.

arguments:(obj)
Flistp
T if OBJECT is a list.  This includes nil.

arguments:(obj)
Fnlistp
T if OBJECT is not a list.  Lists include nil.

arguments:(obj)
Fsymbolp
T if OBJECT is a symbol.

arguments:(obj)
Fvectorp
T if OBJECT is a vector.

arguments:(obj)
Fstringp
T if OBJECT is a string.

arguments:(obj)
Farrayp
T if OBJECT is an array (string or vector).

arguments:(obj)
Fsequencep
T if OBJECT is a sequence (list or array).

arguments:(obj)
Fbufferp
T if OBJECT is an editor buffer.

arguments:(obj)
Fmarkerp
T if OBJECT is a marker (editor pointer).

arguments:(obj)
Finteger-or-marker-p
T if OBJECT is an integer or a marker (editor pointer).

arguments:(obj)
Fsubrp
T if OBJECT is a built-in function.

arguments:(obj)
Fcompiled-function-p
T if OBJECT is a compiled function object (as returned by make-byte-code.)

arguments:(obj)
Fchar-or-string-p
T if OBJECT is a character (a number) or a string.

arguments:(obj)
Fintegerp
T if OBJECT is a number.

arguments:(obj)
Fnatnump
T if OBJECT is a nonnegative number.

arguments:(obj)
Ffloatp
T if OBJECT is a floating point number.

arguments:(obj)
Fnumberp
T if OBJECT is a number (floating point or integer).

arguments:(obj)
Fnumber-or-marker-p
T if OBJECT is a number or a marker.

arguments:(obj)
Fextentp
T if OBJECT is an extent..

arguments:(extent)
Fcar
Return the car of CONSCELL.  If arg is nil, return nil.
Error if arg is not nil and not a cons cell.  See also `car-safe'.

arguments:(list)
Fcar-safe
Return the car of OBJECT if it is a cons cell, or else nil.

arguments:(object)
Fcdr
Return the cdr of CONSCELL.  If arg is nil, return nil.
Error if arg is not nil and not a cons cell.  See also `cdr-safe'.

arguments:(list)
Fcdr-safe
Return the cdr of OBJECT if it is a cons cell, or else  nil.

arguments:(object)
Fsetcar
Set the car of CONSCELL to be NEWCAR.  Returns NEWCAR.

arguments:(cell newcar)
Fsetcdr
Set the cdr of CONSCELL to be NEWCDR.  Returns NEWCDR.

arguments:(cell newcdr)
Fboundp
T if SYMBOL's value is not void.

arguments:(sym)
Ffboundp
T if SYMBOL's function definition is not void.

arguments:(sym)
Fmakunbound
Make SYMBOL's value be void.

arguments:(sym)
Ffmakunbound
Make SYMBOL's function definition be void.

arguments:(sym)
Fsymbol-function
Return SYMBOL's function definition.  Error if that is void.

arguments:(sym)
Fsymbol-plist
Return SYMBOL's property list.

arguments:(sym)
Fsymbol-name
Return SYMBOL's name, a string.

arguments:(sym)
Ffset
Set SYMBOL's function definition to NEWVAL, and return NEWVAL.

arguments:(sym newdef)
Fsetplist
Set SYMBOL's property list to NEWVAL, and return NEWVAL.

arguments:(sym newplist)
Fsymbol-value
Return SYMBOL's value.  Error if that is void.

arguments:(sym)
Fset
Set SYMBOL's value to NEWVAL, and return NEWVAL.

arguments:(sym newval)
Fdefault-boundp
Return T if SYMBOL has a non-void default value.
This is the value that is seen in buffers that do not have their own values
for this variable.

arguments:(sym)
Fdefault-value
Return SYMBOL's default value.
This is the value that is seen in buffers that do not have their own values
for this variable.  The default value is meaningful for variables with
local bindings in certain buffers.

arguments:(sym)
Fset-default
Set SYMBOL's default value to VAL.  SYMBOL and VAL are evaluated.
The default value is seen in buffers that do not have their own values
for this variable.

arguments:(sym value)
Fsetq-default
Set SYMBOL's default value to VAL.  VAL is evaluated; SYMBOL is not.
The default value is seen in buffers that do not have their own values
for this variable.

arguments: (arg1 arg2 &rest args)
Fmake-variable-buffer-local
Make VARIABLE have a separate value for each buffer.
At any time, the value for the current buffer is in effect.
There is also a default value which is seen in any buffer which has not yet
set its own value.
Using `set' or `setq' to set the variable causes it to have a separate value
for the current buffer if it was previously using the default value.
The function `default-value' gets the default value and `set-default' sets it.

arguments:(sym)
Fmake-local-variable
Make VARIABLE have a separate value in the current buffer.
Other buffers will continue to share a common default value.
See also `make-variable-buffer-local'.

arguments:(sym)
Fkill-local-variable
Make VARIABLE no longer have a separate value in the current buffer.
From now on the default value will apply in this buffer.

arguments:(sym)
Findirect-function
Return the function at the end of OBJECT's function chain.
If OBJECT is a symbol, follow all function indirections and return
the final function binding.
If OBJECT is not a symbol, just return it.
Signal a void-function error if the final symbol is unbound.
Signal a cyclic-function-indirection error if there is a loop in the
function chain of symbols.

arguments:(object)
Faref
Return the element of ARRAY at index INDEX.
ARRAY may be a vector or a string, or a byte-code object.  INDEX starts at 0.

arguments:(array idx)
Faset
Store into the element of ARRAY at index INDEX the value NEWVAL.
ARRAY may be a vector or a string.  INDEX starts at 0.

arguments:(array idx newelt)
F=
T if two args, both numbers or markers, are equal.

arguments:(num1 num2)
F<
T if first arg is less than second arg.  Both must be numbers or markers.

arguments:(num1 num2)
F>
T if first arg is greater than second arg.  Both must be numbers or markers.

arguments:(num1 num2)
F<=
T if first arg is less than or equal to second arg.
Both must be numbers or markers.

arguments:(num1 num2)
F>=
T if first arg is greater than or equal to second arg.
Both must be numbers or markers.

arguments:(num1 num2)
F/=
T if first arg is not equal to second arg.  Both must be numbers or markers.

arguments:(num1 num2)
Fzerop
T if NUMBER is zero.

arguments:(num)
Fint-to-string
Convert INT to a string by printing it in decimal.
Uses a minus sign if negative.

arguments:(num)
Fstring-to-int
Convert STRING to an integer by parsing it as a decimal number.

arguments:(str)
F+
Return sum of any number of arguments, which are numbers or markers.

arguments: (&rest args)
F-
Negate number or subtract numbers or markers.
With one arg, negates it.  With more than one arg,
subtracts all but the first from the first.

arguments: (&rest args)
F*
Returns product of any number of arguments, which are numbers or markers.

arguments: (&rest args)
F/
Returns first argument divided by all the remaining arguments.
The arguments must be numbers or markers.

arguments: (arg1 arg2 &rest args)
F%
Returns remainder of first arg divided by second.
Both must be numbers or markers.

arguments:(num1 num2)
Fmax
Return largest of all the arguments (which must be numbers or markers).
The value is always a number; markers are converted to numbers.

arguments: (arg1 &rest args)
Fmin
Return smallest of all the arguments (which must be numbers or markers).
The value is always a number; markers are converted to numbers.

arguments: (arg1 &rest args)
Flogand
Return bitwise-and of all the arguments.
Arguments may be integers, or markers converted to integers.

arguments: (&rest args)
Flogior
Return bitwise-or of all the arguments.
Arguments may be integers, or markers converted to integers.

arguments: (&rest args)
Flogxor
Return bitwise-exclusive-or of all the arguments.
Arguments may be integers, or markers converted to integers.

arguments: (&rest args)
Fash
Return VALUE with its bits shifted left by COUNT.
If COUNT is negative, shifting is actually to the right.
In this case, the sign bit is duplicated.

arguments:(num1 num2)
Flsh
Return VALUE with its bits shifted left by COUNT.
If COUNT is negative, shifting is actually to the right.
In this case,  zeros are shifted in on the left.

arguments:(num1 num2)
F1+
Return NUMBER plus one.  NUMBER may be a number or a marker.
Markers are converted to integers.

arguments:(num)
F1-
Return NUMBER minus one.  NUMBER may be a number or a marker.
Markers are converted to integers.

arguments:(num)
Flognot
Return the bitwise complement of ARG.  ARG must be an integer.

arguments:(num)
Fdirectory-files
Return a list of names of files in DIRECTORY.
There are four optional arguments:
If FULL is non-nil, absolute pathnames of the files are returned.
If MATCH is non-nil, only pathnames containing that regexp are returned.
If NOSORT is non-nil, the list is not sorted--its order is unpredictable.
 NOSORT is useful if you plan to sort the result yourself.
If FILES-ONLY is the symbol t, then only the "files" in the directory
 will be returned; subdirectories will be excluded.  If FILES-ONLY is not
 nil and not t, then only the subdirectories will be returned.  Otherwise,
 if FILES-ONLY is nil (the default) then both files and subdirectories will
 be returned.

arguments:(dirname &optional full match nosort files_only)
Ffile-name-completion
Complete file name FILE in directory DIR.
Returns the longest string
common to all filenames in DIR that start with FILE.
If there is only one and FILE matches it exactly, returns t.
Returns nil if DIR contains no name starting with FILE.

arguments:(file dirname)
Ffile-name-all-completions
Return a list of all completions of file name FILE in directory DIR.
These are all file names in directory DIR which begin with FILE.

arguments:(file dirname)
Ffile-name-all-versions
Return a list of all versions of file name FILE in directory DIR.

arguments:(file dirname)
Ffile-attributes
Return a list of attributes of file FILENAME.
Value is nil if specified file cannot be opened.
Otherwise, list elements are:
 0. t for directory, string (name linked to) for symbolic link, or nil.
 1. Number of links to file.
 2. File uid.
 3. File gid.
 4. Last access time, as a list of two integers.
  First integer has high-order 16 bits of time, second has low 16 bits.
 5. Last modification time, likewise.
 6. Last status change time, likewise.
 7. Size in bytes.
 8. File modes, as a string of ten letters or dashes as in ls -l.
 9. t iff file's gid would change if file were deleted and recreated.
10. inode number.

If file does not exists, returns nil.

arguments:(filename)
Ftime-to-string


arguments:(time)
Vcompletion-ignored-extensions
*Completion ignores filenames ending in any string in this list.
This variable does not affect lists of possible completions,
but does affect the commands that actually do completions.Fopen-termscript
Start writing all terminal output to FILE as well as the terminal.
FILE = nil means just close any termscript file currently open.

arguments:(file)
Fsend-string-to-terminal
Send STRING to the terminal without alteration.
Control characters in STRING will have terminal-dependent effects.

arguments:(str)
Fding
Beep, or flash the screen.
Also, unless an argument is given,
terminate any keyboard macro currently executing.
When called from lisp, the second argument is what sound to make.

arguments:(&optional arg sound)
Finitialize-first-screen
Make redisplay work on the first screen (do this early.)

arguments:()
Vbaud-rate
The output baud rate of the terminal.
On most systems, changing this value will affect the amount of padding
and the other strategic decisions made during redisplay.Vinverse-video
*Non-nil means invert the entire screen display.
This means everything is in inverse video which otherwise would not be.Vvisible-bell
*Non-nil means try to flash the screen to represent a bell.Vno-redraw-on-reenter
*Non-nil means no need to redraw entire screen after suspending.
A non-nil value is useful if the terminal can automatically preserve
Emacs's screen display when you reenter Emacs.
It is up to you to set this variable if your terminal can do that.Vwindow-system
A symbol naming the window-system under which Emacs is running,
such as `x', or nil if emacs is running on an ordinary terminal.Vwindow-system-version
The version number of the window system in use.
For X windows, this is 10 or 11.Vcursor-in-echo-area
Non-nil means put cursor in minibuffer, at end of any message there.Vglyph-table
Table defining how to output a glyph code to the screen.
If not nil, this is a vector indexed by glyph code to define the glyph.
Each element can be:
 integer: a glyph code which this glyph is an alias for.
 string: output this glyph using that string (not impl. in X windows).
 nil: this glyph mod 256 is char code to output,
    and this glyph / 256 is face code for X windows (see `x-set-face').Vstandard-display-table
Display table to use for buffers that specify none.
See `buffer-display-table' for more information.Fdocumentation
Return the documentation string of FUNCTION.

arguments:(fun1)
Fdocumentation-property
Return the documentation string that is SYMBOL's PROP property.
This differs from using `get' only in that it can refer to strings
stored in the `etc/DOC' file.

arguments:(sym prop)
FSnarf-documentation
Used during Emacs initialization, before dumping runnable Emacs,
to find pointers to doc strings stored in `etc/DOC...' and
record them in function definitions.
One arg, FILENAME, a string which does not include a directory.
The file is found in `../etc' now; found in the `exec-directory'
when doc strings are referred to later in the dumped Emacs.

arguments:(filename)
FVerify-documentation
Used to make sure everything went well with Snarf-documentation.
Writes to stderr if not.

arguments:()
Fsubstitute-command-keys
Substitute key descriptions for command names in STRING.
Return a new string which is STRING with substrings of the form \=\[COMMAND]
replaced by either:  a keystroke sequence that will invoke COMMAND,
or "M-x COMMAND" if COMMAND is not on any keys.
Substrings of the form \=\{MAPVAR} are replaced by summaries
(made by describe-bindings) of the value of MAPVAR, taken as a keymap.
Substrings of the form \=\<MAPVAR> specify to use the value of MAPVAR
as the keymap for future \=\[COMMAND] substrings.
\=\= quotes the following character and is discarded;
thus, \=\=\=\= puts \=\= into the output, and \=\=\=\[ puts \=\[ into the output.

arguments:(str)
Vinternal-doc-file-name
Name of file containing documentation strings of built-in symbols.Fint86
Under MS-DOS, call interrupt number INTNO.
REGS is a vector of 8 numbers, specifying the values of the AX, BX,
CX, DX, SI, DI, carry-flag, and FLAGS registers, respectively.  On
entry to the interrupt, the registers will be filled with these values.
On exit from the interrupt, the register values will be copied back
into the REGS vector.  See a book such as the "MS-DOS Encyclopedia"
for more details about the specific interrupts.  Note that you can
easily crash the system if you are not careful.

Under Win-Emacs, the FLAGS value is currently ignored on entry to the
interrupt and is not set on exit.


arguments:(intno regs)
Vdos-inhibit-setdisk
*Non-nil means that changing current drive is inhibited.Fchar-to-string
Convert arg CHAR to a one-character string containing that character.

arguments:(n)
Fstring-to-char
Convert arg STRING to a character, the first character of that string.

arguments:(str)
Fpoint
Return value of point, as an integer.
Beginning of buffer is position (point-min)

arguments:()
Fpoint-marker
Return value of point, as a marker object.
This marker is a copy; you may modify it with reckless abandon.
If the argument to this function is non-nil, then it returns the real
point-marker; modifying the position of this marker willl move point.
It is illegal to change the buffer of it, or make it point nowhere.

arguments:(&optional dont_copy_p)
Fgoto-char
Set point to POSITION, a number or marker.
Beginning of buffer is position (point-min), end is (point-max).

arguments:(n)
Fregion-beginning
Return position of beginning of region, as an integer.

arguments:()
Fregion-end
Return position of end of region, as an integer.

arguments:()
Fzmacs-activate-region
Make the region between `point' and `mark' be in the active (highlighted)
state, if `zmacs-regions' is true.  Only a very small number of commands
should ever do this.

arguments:()
Fzmacs-deactivate-region
Make the region between `point' and `mark' no longer be in the active
(highlighted) state, if `zmacs-regions' is true.  You shouldn't need to call
this; the command loop calls it when appropriate.
Returns t if the region had been active, nil otherwise.

arguments:()
Fmark-marker
Return this buffer's mark, as a marker object.
If `zmacs-regions' is true, then this returns nil unless the region is
currently in the active (hilighted) state.  With an argument of t, this
returns the mark (if there is one) regardless of the zmacs-region state.
You should *generally* not use the mark unless the region is active, if
the user has expressed a preference for the zmacs-region model.
Watch out!  Moving this marker changes the mark position.
If you set the marker not to point anywhere, the buffer will have no mark.

arguments:(&optional inactive_p)
Fsave-excursion
Save point, mark, and current buffer; execute BODY; restore those things.
Executes BODY just like `progn'.
The values of point, mark and the current buffer are restored
even in case of abnormal exit (throw or error).

arguments: (&rest args)
Fbuffer-size
Return the number of characters in the current buffer.

arguments:()
Fpoint-min
Return the minimum permissible value of point in the current buffer.
This is 1, unless a clipping restriction is in effect.

arguments:()
Fpoint-min-marker
Return a marker to the minimum permissible value of point in this buffer.
This is the beginning, unless a clipping restriction is in effect.

arguments:()
Fpoint-max
Return the maximum permissible value of point in the current buffer.
This is (1+ (buffer-size)), unless a clipping restriction is in effect,
in which case it is less.

arguments:()
Fpoint-max-marker
Return a marker to the maximum permissible value of point in this buffer.
This is (1+ (buffer-size)), unless a clipping restriction is in effect,
in which case it is less.

arguments:()
Ffollowing-char
Return the character following point, as a number.
At the end of the buffer or accessible region, return 0.

arguments:()
Fpreceding-char
Return the character preceding point, as a number.
At the beginning of the buffer or accessible region, return 0.

arguments:()
Fbobp
Return T if point is at the beginning of the buffer.
If the buffer is narrowed, this means the beginning of the narrowed part.

arguments:()
Feobp
Return T if point is at the end of the buffer.
If the buffer is narrowed, this means the end of the narrowed part.

arguments:()
Fbolp
Return T if point is at the beginning of a line.

arguments:()
Feolp
Return T if point is at the end of a line.
`End of a line' includes point being at the end of the buffer.

arguments:()
Fchar-after
Return character in current buffer at position POS.
POS is an integer or a buffer pointer.
If POS is out of range, the value is nil.

arguments:(pos)
Fuser-login-name
Return the name under which the user logged in, as a string.
This is based on the effective uid, not the real uid.
Also, if the environment variable USER or LOGNAME is set,
that determines the value of this function.

arguments:()
Fuser-real-login-name
Return the name of the user's real uid, as a string.
Differs from `user-login-name' when running under `su'.

arguments:()
Fuser-uid
Return the effective uid of Emacs, as an integer.

arguments:()
Fuser-real-uid
Return the real uid of Emacs, as an integer.

arguments:()
Fuser-full-name
Return the full name of the user logged in, as a string.

arguments:()
Fsystem-name
Return the name of the machine you are running on, as a string.

arguments:()
Fcurrent-time
Return the current time, as the number of seconds since 12:00 AM January 1970.
The time is returned as a list of three integers.  The first has the
most significant 16 bits of the seconds, while the second has the
least significant 16 bits.  The third integer gives the microsecond
count.

The microsecond count is zero on systems that do not provide
resolution finer than a second.

arguments:()
Fcurrent-time-seconds
Returns the current time as the number of seconds since Jan. 1, 1970, 00:00,
Greenwich Mean Time.  Since emacs can't represent integers that large, this
is returned as a cons of two 16-bit numbers.  You can pass this value as an
argument to current-time-string to get that time as a string.

arguments:(&optional cons)
Fcurrent-time-string
Return the current time, as a human-readable string.
Programs can use it too, since the number of columns in each field is fixed.
The format is `Sun Sep 16 01:03:52 1973'.
If the optional argument is non-nil, it must be a cons of two integers, which
are the upper and lower 16 bits of a time in seconds (such as the value
returned by the current-time-seconds function.
In a future Emacs version, the time zone may be added at the end.

arguments:(&optional arg)
Fcurrent-time-zone
Return the offset, savings state, and names for the current time zone.
This returns a list of the form (OFFSET SAVINGS-FLAG STANDARD SAVINGS).
OFFSET is an integer specifying how many minutes east of Greenwich the
    current time zone is located.  A negative value means west of
    Greenwich. Note that this describes the standard time;  if daylight
    savings time is in effect, it does not affect this value.
SAVINGS-FLAG is non-nil iff daylight savings time or some other sort
    of seasonal time adjustment is in effect.
STANDARD is a string giving the name of the time zone when no seasonal
    time adjustment is in effect.
SAVINGS is a string giving the name of the time zone when there is a
    seasonal time adjustment in effect.
If the local area does not use a seasonal time adjustment,
SAVINGS-FLAG will always be nil, and STANDARD and SAVINGS will be the
same.

arguments:()
Fset-default-file-mode
Set Unix `umask' value to ARGUMENT, and return old value.
The `umask' value is the default protection mode for new files.

arguments:(nmask)
Funix-sync
Tell Unix to finish all pending disk updates.

arguments:()
Finsert
Insert the arguments, either strings or characters, at point.
Point moves forward so that it ends up after the inserted text.
Any other markers at the point of insertion remain before the text.

arguments: (&rest args)
Finsert-before-markers
Insert strings or characters at point, relocating markers after the text.
Point moves forward so that it ends up after the inserted text.
Any other markers at the point of insertion also end up after the text.

arguments: (&rest args)
Finsert-char
Insert COUNT (second arg) copies of CHAR (first arg).
Point and all markers are affected as in the function `insert'.
Both arguments are required.

arguments:(chr count)
Fbuffer-substring
Return the contents of part of the current buffer as a string.
The two arguments START and END are character positions;
they can be in either order.

arguments:(b e)
Fbuffer-string
Return the contents of the current buffer as a string.

arguments:()
Finsert-buffer-substring
Insert before point a substring of the contents buffer BUFFER.
BUFFER may be a buffer or a buffer name.
Arguments START and END are character numbers specifying the substring.
They default to the beginning and the end of BUFFER.

arguments:(buf &optional b e)
Fcompare-buffer-substrings
Compare two substrings of two buffers; return result as number.
the value is -N if first string is less after N-1 chars,
+N if first string is greater after N-1 chars, or 0 if strings match.
Each substring is represented as three arguments: BUFFER, START and END.
That makes six args in all, three for each substring.

The value of `case-fold-search' in the current buffer
determines whether case is significant or ignored.

arguments:(buffer1 start1 end1 buffer2 start2 end2)
Fsubst-char-in-region
From START to END, replace FROMCHAR with TOCHAR each time it occurs.
If optional arg NOUNDO is non-nil, don't record this change for undo
and don't mark the buffer as really changed.

arguments:(start end fromchar tochar &optional noundo)
Ftranslate-region
From START to END, translate characters according to TABLE.
TABLE is a string; the Nth character in it is the mapping
for the character with code N.  Returns the number of characters changed.

arguments:(start end table)
Fdelete-region
Delete the text between point and mark.
When called from a program, expects two arguments,
positions (integers or markers) specifying the stretch to be deleted.

arguments:(b e)
Fwiden
Remove restrictions (narrowing) from current buffer.
This allows the buffer's full text to be seen and edited.

arguments:()
Fnarrow-to-region
Restrict editing in this buffer to the current region.
The rest of the text becomes temporarily invisible and untouchable
but is not deleted; if you save the buffer in a file, the invisible
text is included in the file.  \[widen] makes all visible again.
See also `save-restriction'.

When calling from a program, pass two arguments; positions (integers
or markers) bounding the text that should remain visible.

arguments:(b e)
Fsave-restriction
Execute BODY, saving and restoring current buffer's restrictions.
The buffer's restrictions make parts of the beginning and end invisible.
(They are set up with `narrow-to-region' and eliminated with `widen'.)
This special form, `save-restriction', saves the current buffer's restrictions
when it is entered, and restores them when it is exited.
So any `narrow-to-region' within BODY lasts only until the end of the form.
The old restrictions settings are restored
even in case of abnormal exit (throw or error).

The value returned is the value of the last form in BODY.

`save-restriction' can get confused if, within the BODY, you widen
and then make changes outside the area within the saved restrictions.

Note: if you are using both `save-excursion' and `save-restriction',
use `save-excursion' outermost:
    (save-excursion (save-restriction ...))

arguments: (&rest args)
Fmessage
Print a one-line message at the bottom of the screen.
The first argument is a control string.
It may contain %s or %d or %c to print successive following arguments.
%s means print an argument as a string, %d means print as number in decimal,
%c means print a number as a single character.
The argument used by %s must be a string or a symbol;
the argument used by %d or %c must be a number.

If the only argument is nil, just erase any previous message.

arguments: (arg1 &rest args)
Fformat
Format a string out of a control-string and arguments.
The first argument is a control string.
The other arguments are substituted into it to make the result, a string.
It may contain %-sequences meaning to substitute the next argument.
%s means print strings using `princ' and other objects using `prin1'.
%S means print all objects using `prin1' (including strings.)
%d means print as number in decimal (%o octal, %x hex).
%c means print a number as a single character.
The argument used for %d, %o, %x or %c must be a number.
Use %% to put a single % into the output.

arguments: (arg1 &rest args)
Fchar-equal
Return t if two characters match, optionally ignoring case.
Both arguments must be characters (i.e. integers).
Case is ignored if `case-fold-search' is non-nil in the current buffer.

arguments:(c1 c2)
Fgetenv
Return the value of environment variable VAR, as a string.
VAR should be a string.  Value is nil if VAR is undefined in the environment.

arguments:(str)
Vsystem-name
The name of the machine Emacs is running on.Vuser-full-name
The full name of the user logged in.Vuser-name
The user's name, based on the effective uid.Vuser-real-name
The user's name, base upon the real uid.Vzmacs-regions
*Whether LISPM-style active regions should be used.
This means that commands which operate on the region (the area between the
point and the mark) will only work while the region is in the ``active''
state, which is indicated by hilighting.  Executing most commands causes
the region to not be in the active state, so (for example) \[kill-region] will only
work immediately after activating the region.

More specifically:

 - Commands which operate on the region only work if the region is active.
 - Only a very small set of commands cause the region to become active:
   Those commands whose semantics are to mark an area, like mark-defun.
 - The region is deactivated after each command that is executed, except that:
 - "Motion" commands do not change whether the region is active or not.

set-mark-command (C-SPC) pushes a mark and activates the region.  Moving the
cursor with normal motion commands (C-n, C-p, etc) will cause the region
between point and the recently-pushed mark to be highlighted.  It will
remain highlighted until some non-motion comand is executed.

exchange-point-and-mark (\[exchange-point-and-mark]) activates the region.  So if you mark a
region and execute a command that operates on it, you can reactivate the
same region with \[exchange-point-and-mark] (or perhaps \[exchange-point-and-mark] \[exchange-point-and-mark]) to operate on it
again.

Generally, commands which push marks as a means of navigation (like
beginning-of-buffer and end-of-buffer (M-< and M->)) do not activate the
region.  But commands which push marks as a means of marking an area of
text (like mark-defun (\[mark-defun]), mark-word (\[mark-word]) or mark-whole-buffer (\[mark-whole-buffer]))
do activate the region.Vzmacs-activate-region-hook
Function or functions called when the region becomes active;
see the variable `zmacs-regions'.Vzmacs-deactivate-region-hook
Function or functions called when the region becomes inactive;
see the variable `zmacs-regions'.Vzmacs-update-region-hook
Function or functions called when the active region changes.
This is called after each command that sets `region-stays' to t.
See the variable `zmacs-regions'.Vzmacs-region-stays
Commands which do not wish to affect whether the region is currently
hilighted should set this to t.  Normally, the region is turned off after
executing each command that did not explicitly turn it on with the function
zmacs-activate-region. Setting this to true lets a command be non-intrusive.
See the variable `zmacs-regions'.Fhashtablep
Returns T if OBJ is a hashtable, else NIL.

arguments:(obj)
Fmake-hashtable
Make a hashtable of initial size SIZE.

arguments:(size)
Fcopy-hashtable
Make a new hashtable which contains the same keys and values
as the given table.  The keys and values will not themselves be copied.

arguments:(old_table)
Fgethash
Find hash value for KEY in TABLE.
If there is no corresponding value, return DEFAULT (default nil)

arguments:(key table &optional defalt)
Fremhash
Remove hash value for KEY in TABLE.

arguments:(key table)
Fputhash
Hash KEY to VAL in TABLE.

arguments:(key val table)
Fclrhash
Flush TABLE.

arguments:(table)
Fhashtable-fullness
Returns number of entries in TABLE.

arguments:(table)
Fmaphash
Map FUNCTION over entries in TABLE, calling it with two args,
each key and value in the table.

arguments:(function table)
Frun-emacs-from-temacs
Do not call this.  It will reinitialize your Emacs.  You'll be sorry.

arguments: (&rest args)
Fkill-emacs
Exit the Emacs job and kill it.  Ask for confirmation, without argument.
If ARG is an integer, return ARG as the exit program code.
If ARG is a  string, stuff it as keyboard input.

The value of `kill-emacs-hook', if not void,
is a list of functions (of no args),
all of which are called before Emacs is actually killed.

arguments:(&optional arg)
Fdump-emacs
Dump current state of Emacs into executable file FILENAME.
Take symbols from SYMFILE (presumably the file you executed to run Emacs).
This is used in the file `loadup.el' when building Emacs.

Bind `command-line-processed' to nil before dumping,
if you want the dumped Emacs to process its command line
and announce itself normally when it is run.

arguments:(intoname symname)
Fnoninteractive
Non-nil return value means Emacs is running without interactive terminal.

arguments:()
Vcommand-line-args
Args passed by shell to Emacs, as a list of strings.Vinvocation-name
Name of file used to invoke editing session.
This is the same as `(file-name-nondirectory execution-path)'.Vexecution-path
Pathname of executable emacs program now running.Vsystem-type
Value is symbol indicating type of operating system you are using.Vnoninteractive
Non-nil means Emacs is running without interactive terminal.Fgetenv
Return the value of environment variable VAR, as a string.
When invoked interactively, print the value in the echo area.
VAR is a string, the name of the variable,
 or the symbol t, meaning to return an alist representing the
 current environment.

arguments:(str &optional interactivep)
Fsetenv
Set the value of environment variable VAR to VALUE.
Both args must be strings.  Returns VALUE.

arguments:(str &optional val)
For
Eval args until one of them yields non-nil, then return that value.
The remaining args are not evalled at all.
If all args return nil, return nil.

arguments: (&rest args)
Fand
Eval args until one of them yields nil, then return nil.
The remaining args are not evalled at all.
If no arg yields nil, return the last arg's value.

arguments: (&rest args)
Fif
(if COND THEN ELSE...): if COND yields non-nil, do THEN, else do ELSE...
Returns the value of THEN or the value of the last of the ELSE's.
THEN must be one expression, but ELSE... can be zero or more expressions.
If COND yields nil, and there are no ELSE's, the value is nil.

arguments: (arg1 arg2 &rest args)
Fcond
(cond CLAUSES...): try each clause until one succeeds.
Each clause looks like (CONDITION BODY...).  CONDITION is evaluated
and, if the value is non-nil, this clause succeeds:
then the expressions in BODY are evaluated and the last one's
value is the value of the cond-form.
If no clause succeeds, cond returns nil.
If a clause has one element, as in (CONDITION),
CONDITION's value if non-nil is returned from the cond-form.

arguments: (&rest args)
Fprogn
(progn BODY...): eval BODY forms sequentially and return value of last one.

arguments: (&rest args)
Fprog1
(prog1 FIRST BODY...): eval FIRST and BODY sequentially; value from FIRST.
The value of FIRST is saved during the evaluation of the remaining args,
whose values are discarded.

arguments: (arg1 &rest args)
Fprog2
(prog1 X Y BODY...): eval X, Y and BODY sequentially; value from Y.
The value of Y is saved during the evaluation of the remaining args,
whose values are discarded.

arguments: (arg1 arg2 &rest args)
Fsetq
(setq SYM VAL SYM VAL ...): set each SYM to the value of its VAL.
The SYMs are not evaluated.  Thus (setq x y) sets x to the value of y.
Each SYM is set before the next VAL is computed.

arguments: (&rest args)
Fquote
Return the argument, without evaluating it.  `(quote x)' yields `x'.

arguments: (arg1 &rest args)
Ffunction
Like `quote', but preferred for objects which are functions.
In byte compilation, `function' causes its argument to be compiled.
`quote' cannot do that.

arguments: (arg1 &rest args)
Finteractive-p
Return t if function in which this appears was called interactively.
This means that the function was called with call-interactively (which
includes being called as the binding of a key)
and input is currently coming from the keyboard (not in keyboard macro).

arguments:()
Fdefun
(defun NAME ARGLIST [DOCSTRING] BODY...): define NAME as a function.
The definition is (lambda ARGLIST [DOCSTRING] BODY...).
See also the function `interactive'.

arguments: (arg1 arg2 &rest args)
Fdefmacro
(defmacro NAME ARGLIST [DOCSTRING] BODY...): define NAME as a macro.
The definition is (macro lambda ARGLIST [DOCSTRING] BODY...).
When the macro is called, as in (NAME ARGS...),
the function (lambda ARGLIST BODY...) is applied to
the list ARGS... as it appears in the expression,
and the result should be a form to be evaluated instead of the original.

arguments: (arg1 arg2 &rest args)
Fdefvar
(defvar SYMBOL INITVALUE DOCSTRING): define SYMBOL as a variable.
You are not required to define a variable in order to use it,
but the definition can supply documentation and an initial value
in a way that tags can recognize.

INITVALUE is evaluated, and used to set SYMBOL, only if SYMBOL's value is void.
If SYMBOL is buffer-local, its default value is what is set;
 buffer-local values are not affected.
INITVALUE and DOCSTRING are optional.
If DOCSTRING starts with *, this variable is identified as a user option.
 This means that M-x set-variable and M-x edit-options recognize it.
If INITVALUE is missing, SYMBOL's value is not set.

arguments: (arg1 &rest args)
Fdefconst
(defconst SYMBOL INITVALUE DOCSTRING): define SYMBOL as a constant variable.
The intent is that programs do not change this value, but users may.
Always sets the value of SYMBOL to the result of evalling INITVALUE.
If SYMBOL is buffer-local, its default value is what is set;
 buffer-local values are not affected.
DOCSTRING is optional.
If DOCSTRING starts with *, this variable is identified as a user option.
 This means that M-x set-variable and M-x edit-options recognize it.

Note: do not use `defconst' for user options in libraries that are not
normally loaded, since it is useful for users to be able to specify
their own values for such variables before loading the library.
Since `defconst' unconditionally assigns the variable,
it would override the user's choice.

arguments: (arg1 arg2 &rest args)
Fuser-variable-p
Returns t if VARIABLE is intended to be set and modified by users.
(The alternative is a variable used internally in a Lisp program.)
Determined by whether the first character of the documentation
for the variable is "*"

arguments:(variable)
Flet*
(let* VARLIST BODY...): bind variables according to VARLIST then eval BODY.
The value of the last form in BODY is returned.
Each element of VARLIST is a symbol (which is bound to nil)
or a list (SYMBOL VALUEFORM) (which binds SYMBOL to the value of VALUEFORM).
Each VALUEFORM can refer to the symbols already bound by this VARLIST.

arguments: (arg1 &rest args)
Flet
(let VARLIST BODY...): bind variables according to VARLIST then eval BODY.
The value of the last form in BODY is returned.
Each element of VARLIST is a symbol (which is bound to nil)
or a list (SYMBOL VALUEFORM) (which binds SYMBOL to the value of VALUEFORM).
All the VALUEFORMs are evalled before any symbols are bound.

arguments: (arg1 &rest args)
Fwhile
(while TEST BODY...): if TEST yields non-nil, eval BODY... and repeat.
The order of execution is thus TEST, BODY, TEST, BODY and so on
until TEST returns nil.

arguments: (arg1 &rest args)
Fmacroexpand
Return result of expanding macros at top level of FORM.
If FORM is not a macro call, it is returned unchanged.
Otherwise, the macro is expanded and the expansion is considered
in place of FORM.  When a non-macro-call results, it is returned.

The second optional arg ENVIRONMENT species an environment of macro
definitions to shadow the loaded ones for use in file byte-compilation.

arguments:(form &optional env)
Fcatch
(catch TAG BODY...): eval BODY allowing nonlocal exits using `throw'.
TAG is evalled to get the tag to use.  Then the BODY is executed.
Within BODY, (throw TAG) with same tag exits BODY and exits this `catch'.
If no throw happens, `catch' returns the value of the last BODY form.
If a throw happens, it specifies the value to return from `catch'.

arguments: (arg1 &rest args)
Fthrow
(throw TAG VALUE): throw to the catch for TAG and return VALUE from it.
Both TAG and VALUE are evalled.

arguments:(tag val)
Funwind-protect
Do BODYFORM, protecting with UNWINDFORMS.
Usage looks like (unwind-protect BODYFORM UNWINDFORMS...).
If BODYFORM completes normally, its value is returned
after executing the UNWINDFORMS.
If BODYFORM exits nonlocally, the UNWINDFORMS are executed anyway.

arguments: (arg1 &rest args)
Fcondition-case
Regain control when an error is signaled.
Usage looks like (condition-case VAR BODYFORM HANDLERS...).
executes BODYFORM and returns its value if no error happens.
Each element of HANDLERS looks like (CONDITION-NAME BODY...)
where the BODY is made of Lisp expressions.

A handler is applicable to an error
if CONDITION-NAME is one of the error's condition names.
If an error happens, the first applicable handler is run.

When a handler handles an error,
control returns to the condition-case and the handler BODY... is executed
with VAR bound to (SIGNALED-CONDITIONS . SIGNAL-DATA).
VAR may be nil; then you do not get access to the signal information.

The value of the last BODY form is returned from the condition-case.
See also the function `signal' for more info.

arguments: (arg1 arg2 &rest args)
Fsignal
Signal an error.  Args are SIGNAL-NAME, and associated DATA.
A signal name is a symbol with an `error-conditions' property
that is a list of condition names.
A handler for any of those names will get to handle this signal.
The symbol `error' should normally be one of them.

DATA should be a list.  Its elements are printed as part of the error message.
If the signal is handled, DATA is made available to the handler.
See also the function `condition-case'.

arguments:(sig data)
Fcommandp
T if FUNCTION makes provisions for interactive calling.
This means it contains a description for how to read arguments to give it.
The value is nil for an invalid function or a symbol with no function
definition.

Interactively callable functions include strings and vectors (treated
as keyboard macros), lambda-expressions that contain a top-level call
to `interactive', autoload definitions made by `autoload' with non-nil
fourth argument, and some of the built-in functions of Lisp.

Also, a symbol satisfies `commandp' if its function definition does so.

arguments:(function)
Fautoload
Define FUNCTION to autoload from FILE.
FUNCTION is a symbol; FILE is a file name string to pass to `load'.
Third arg DOCSTRING is documentation for the function.
Fourth arg INTERACTIVE if non-nil says function can be called interactively.
Fifth arg MACRO if non-nil says the function is really a macro.
Third through fifth args give info about the real definition.
They default to nil.
If FUNCTION is already defined other than as an autoload,
this does nothing and returns nil.

arguments:(function file &optional docstring interactive macro)
Feval
Evaluate FORM and return its value.

arguments:(form)
Fapply
Call FUNCTION with our remaining args, using our last arg as list of args.
Thus, (apply '+ 1 2 '(3 4)) returns 10.

arguments: (arg1 arg2 &rest args)
Ffuncall
Call first argument as a function, passing remaining arguments to it.
Thus,  (funcall 'cons 'x 'y)  returns  (x . y).

arguments: (arg1 &rest args)
Fbacktrace-debug
Set the debug-on-exit flag of eval frame LEVEL levels down to FLAG.
The debugger is entered when that frame exits, if the flag is non-nil.

arguments:(level flag)
Fbacktrace
Print a trace of Lisp function calls currently active.
Output stream used is value of `standard-output'.

arguments:(&optional stream)
Fbacktrace-frame
Return the function and arguments N frames up from current execution point.
If that frame has not evaluated the arguments yet (or is a special form),
the value is (nil FUNCTION ARG-FORMS...).
If that frame has evaluated its arguments and called its function already,
the value is (t FUNCTION ARG-VALUES...).
A &rest arg is represented as the tail of the list ARG-VALUES.
FUNCTION is whatever was supplied as car of evaluated list,
or a lambda expression for macro calls.
If N is more than the number of frames, the value is nil.

arguments:(nframes)
Vmax-specpdl-size
Limit on number of Lisp variable bindings & unwind-protects before error.Vmax-lisp-eval-depth
Limit on depth in `eval', `apply' and `funcall' before error.
This limit is to catch infinite recursions for you before they cause
actual stack overflow in C, which would be fatal for Emacs.
You can safely make it considerably larger than its default value,
if that proves inconveniently small.Vquit-flag
Non-nil causes `eval' to abort, unless `inhibit-quit' is non-nil.
Typing C-G sets `quit-flag' non-nil, regardless of `inhibit-quit'.Vinhibit-quit
Non-nil inhibits C-g quitting from happening immediately.
Note that `quit-flag' will still be set by typing C-g,
so a quit will be signalled as soon as `inhibit-quit' is nil.
To prevent this happening, set `quit-flag' to nil
before making `inhibit-quit' nil.Vstack-trace-on-error
*Non-nil means automatically display a backtrace buffer
after any error that is handled by the editor command loop.
If the value is a list, an error only means to display a backtrace
if one of its condition symbols appears in the list.Vdebug-on-error
*Non-nil means enter debugger if an error is signalled.
Does not apply to errors handled by `condition-case'.
If the value is a list, an error only means to enter the debugger
if one of its condition symbols appears in the list.
See also variable `debug-on-quit'.Vdebug-on-quit
*Non-nil means enter debugger if quit is signalled (C-G, for example).
Does not apply if quit is handled by a `condition-case'.Vdebug-on-next-call
Non-nil means enter debugger before next `eval', `apply' or `funcall'.Vdebugger
Function to call to invoke debugger.
If due to frame exit, args are `exit' and the value being returned;
 this function's value will be returned instead of that.
If due to error, args are `error' and a list of the args to `signal'.
If due to `apply' or `funcall' entry, one arg, `lambda'.
If due to `eval' entry, one arg, t.Vmocklisp-arguments
While in a mocklisp function, the list of its unevaluated args.Vrun-hooks
Set to the function `run-hooks', if that function has been defined.
Otherwise, nil (in a bare Emacs without preloaded Lisp code).Fallocate-event
Returns an empty event structure.
WARNING, the event object returned may be a reused one; see the function
`deallocate-event'.

arguments:()
Fdeallocate-event
Allow the given event structure to be reused.  You MUST NOT use this
event object after calling this function with it.  You will lose.
It is not necessary to call this function, as event objects are garbage-
collected like all other objects; however, it may be more efficient to
explicitly deallocate events when you are sure that that is safe.

arguments:(event)
Fcopy-event
Make a copy of the given event object.  If a second argument is given,
the first event is copied into the second and the second is returned.
If the second argument is not supplied (or is nil) then a new event will
be made as with `allocate-event.'  See also the function `deallocate-event'.

arguments:(event1 &optional event2)
Finput-pending-p
T if command input is currently available with no waiting.
Actually, the value is nil only if we can be sure that no input is available.

arguments:()
Fenqueue-eval-event
Add an eval event to the back of the queue.
(enqueue-eval-event <function> <object>)
It will be the next event read after all pending events.

arguments:(function object)
Fnext-event
Given an event structure, fills it in with the next event available
from the window system or terminal driver.  Pass this object to
dispatch-event to handle it.  See also the function next-command-event,
which is often more appropriate.

arguments:(event)
Fnext-command-event
Given an event structure, fills it in with the next keyboard, mouse
press, or mouse release event available from the user.  If there are
non-command events available (mouse motion, sub-process output, etc) then
these will be executed (with `dispatch-event') and discarded.  This
function is provided as a convenience; it is equivalent to the elisp code

    (while (progn
        (next-event event)
            (not (or (key-press-event-p event)
                     (button-press-event-p event)
                     (button-release-event-p event)
                     (menu-event-p event))))
      (dispatch-event event))


arguments:(event)
Fread-char
Read a character from the command input (keyboard or macro).
If a mouse click is detected, an error is signalled.  The character typed
is returned as an ASCII value.  This is most likely the wrong thing for you
to be using: consider using the `next-command-event' function instead.

arguments:()
Fdiscard-input
Discard the contents of the terminal input buffer.
Also cancel any kbd macro being defined.

arguments:()
Faccept-process-output
Allow any pending output from subprocesses to be read by Emacs.
It is read into the process' buffers or given to their filter functions.
Non-nil arg PROCESS means do not return until some output has been received
from PROCESS.

arguments:(&optional proc)
Fsleep-for
Pause, without updating display, for ARG seconds.
ARG may be a float, meaning pause for some fractional part of a second.

arguments:(n)
Fsit-for
Perform redisplay, then wait for ARG seconds or until user input is
available.  ARG may be a float, meaning a fractional part of a second.
Optional second arg non-nil means don't redisplay, just wait for input.
Redisplay is preempted as always if user input arrives, and does not
happen if input is available before it starts.
Value is t if waited the full time with no input arriving.

arguments:(n &optional nodisp)
Fsleep-for-millisecs
Pause, without updating display, for ARG milliseconds.
This function is obsolete; call `sleep-for' with a float instead.

arguments:(n)
Fadd-timeout
SECS is a number of seconds, expressed as an integer or a float.
FUNCTION will be called after that many seconds have elapsed, with one
argument, the given OBJECT.  If the optional RESIGNAL argument is provided,
then after this timeout expires, `add-timeout' will automatically be called
again with RESIGNAL as the first argument.

This function returns an object which is the `id' of this particular timeout.
You can pass that object to `disable-timeout' to turn off the timeout before
it has been signalled.

The number of seconds may be expressed as a floating-point number, in which
case some fractional part of a second will be used.  Caveat: the usable
timeout granularity will vary from system to system.

Adding a timeout causes a timeout event to be returned by `next-event', and
the function will be invoked by `dispatch-event,' so if emacs is in a tight
loop, the function will not be invoked until the next call to sit-for or
until the return to top-level (the same is true of process filters.)

WARNING: if you are thinking of calling add-timeout from inside of a
callback function as a way of resignalling a timeout, think again.  There
is a race condition.  That's why the RESIGNAL argument exists.

arguments:(secs function object &optional resignal)
Fdisable-timeout
Given a timeout id number as returned by `add-timeout', this function
will cause that timeout to not be signalled if it hasn't been already.

arguments:(id)
Fdispatch-event
Given an event object returned by next-event, execute it.

arguments:(event)
Fread-key-sequence
Read a sequence of keystrokes or mouse clicks and return a vector of the
event objects read.  The vector is newly created, but the event objects are
reused: if you want to hold a pointer to them beyond the next call to this
function, you must copy them first.

The sequence read is sufficient to specify a non-prefix command starting
from the current local and global keymaps.  A C-g typed while in this
function is treated like any other character, and `quit-flag' is not set.
One arg, PROMPT, is a prompt string, or nil meaning do not prompt specially.

If the user selects a menu item while we are prompting for a key-sequence,
the returned value will be a vector of a single menu-selection event.
An error will be signalled if you pass this value to `lookup-key' or a
related function.

arguments:(prompt)
Vecho-keystrokes
*Nonzero means echo unfinished commands after this many seconds of pause.Vauto-save-interval
*Number of keyboard input characters between auto-saves.
Zero means disable autosaving due to number of characters typed.
See also the variable `auto-save-timeout'.Fevent-to-character
Returns the closest ASCII approximation to the given event object.
If the event isn't a keypress, this returns nil.
If the second argument is non-nil, then this is lenient in its
translation; it will ignore modifier keys other than control and meta,
and will ignore the shift modifier on those characters which have no
shifted ASCII equivalent (Control-Shift-A for example, will be mapped to
the same ASCII code as Control-A.)  If the second arg is nil, then nil
will be returned for events which have no direct ASCII equivalent.

arguments:(event &optional lenient)
Fcharacter-to-event
Converts a numeric ASCII value to an event structure, replete with
bucky bits.  The character is the first argument, and the event to fill
in is the second.  This function contains knowledge about what the codes
``mean'' -- for example, the number 9 is converted to the character ``Tab'',
not the distinct character ``Control-I''.

If the optional second argument is an event, it is modified; otherwise, a
new event object is created.

Beware that character-to-event and event-to-character are not strictly
inverse functions, since events contain much more information than the
ASCII character set can encode.

arguments:(ch &optional event)
Feventp
True if the argument is an event object.

arguments:(obj)
Fkey-press-event-p
True if the argument is a key-press event object.

arguments:(obj)
Fbutton-press-event-p
True if the argument is a mouse-button-press event object.

arguments:(obj)
Fbutton-release-event-p
True if the argument is a mouse-button-release event object.

arguments:(obj)
Fbutton-event-p
True if the argument is a button-press or button-release event object.

arguments:(obj)
Fmotion-event-p
True if the argument is a mouse-motion event object.

arguments:(obj)
Fprocess-event-p
True if the argument is a process-output event object.

arguments:(obj)
Ftimeout-event-p
True if the argument is a timeout event object.

arguments:(obj)
Fmenu-event-p
True if the argument is a menu event object.

arguments:(obj)
Feval-event-p
True if the argument is an `eval' or `menu' event object.

arguments:(obj)
Fevent-timestamp
Returns the timestamp of the given event object.

arguments:(event)
Fevent-key
Returns the KeySym of the given key-press event.  This will be the
ASCII code of a printing character, or a symbol.

arguments:(event)
Fevent-button
Returns the button-number of the given mouse-button-press event.

arguments:(event)
Fevent-modifier-bits
Returns a number representing the modifier keys which were down
when the given mouse or keyboard event was produced.  See also the function
event-modifiers.

arguments:(event)
Fevent-modifiers
Returns a list of symbols, the names of the modifier keys which
were down when the given mouse or keyboard event was produced.
See also the function event-modifier-bits.

arguments:(event)
Fevent-x-pixel
Returns the X position of the given mouse-motion, button-press, or
button-release event in pixels.

arguments:(event)
Fevent-y-pixel
Returns the Y position of the given mouse-motion, button-press, or
button-release event in pixels.

arguments:(event)
Fevent-window
Given a mouse motion, button press, or button release event, compute
and return the window on which that event occurred.  This may be nil if
the event did not occur in an emacs window (in the border or modeline.)

arguments:(event)
Fevent-point
Returns the character position of the given mouse-motion, button-press,
or button-release event.  If the event did not occur over a window, or did
not occur over text, then this returns nil.  Otherwise, it returns an index
into the buffer visible in the event's window.

arguments:(event)
Fevent-x
Returns the X position of the given mouse-motion, button-press, or
button-release event in characters.

arguments:(event)
Fevent-y
Returns the Y position of the given mouse-motion, button-press, or
button-release event in characters.

arguments:(event)
Fevent-glyph
If the given mouse-motion, button-press, or button-release event happened
on top of a glyph, this returns it; else nil.

arguments:(event)
Fevent-process
Returns the process of the given proces-output event.

arguments:(event)
Fevent-function
Returns the callback function of the given timeout, menu, or eval event.

arguments:(event)
Fevent-object
Returns the callback function argument of the given timeout, menu, or
eval event.

arguments:(event)
Vcharacter-set-property
A symbol used to look up the 8-bit character of a keysym.
To convert a keysym symbol to an 8-bit code, as when that key is
bound to self-insert-command, we will look up the property that this
variable names on the property list of the keysym-symbol.  The window-
system-specific code will set up appropriate properties and set this
variable.Fmap-extents
Usage: (map-extents FUNCTION BUFFER FROM TO MAPARG)
Map FUNCTION over the extents which overlap region in BUFFER starting at
 FROM and ending at TO.  FUNCTION is called with arguments (extent, MAPARG).
All arguments except FUNCTION are optional, with FROM, TO, MAPARG, and
 BUFFER defaulting to the beginning of BUFFER, the end of BUFFER, NIL, and
 current buffer, respectively.
If the function returns non-nil, then map-extents returns immediately.
map-extents always returns nil.

arguments:(function &optional buffer from to maparg closed_end)
Fhighlight-extent
If EXTENT is `highlightable' (has the 'highlight property) then highlight
it (by using merging it with 'highlight face.)  If FLAG is nil, then
unhighlight it instead.

arguments:(extent_obj &optional flag)
Fforce-highlight-extent
Highlight any EXTENT if FLAG is not nil, else unhighlight it.
This is the same as `highlight-extent', except that it will work even
on extents without the 'highlight property.

arguments:(extent_obj &optional flag)
Fextent-start-position
Return start position of EXTENT.

arguments:(extent_obj)
Fextent-end-position
Return first position after EXTENT.

arguments:(extent_obj)
Fextent-length
Return length of EXTENT in characters.

arguments:(extent_obj)
Fextent-buffer
Return buffer of EXTENT.

arguments:(extent_obj)
Fextent-to-generic-id
Return Energize ID of buffer of EXTENT.

arguments:(extent_obj)
Fmake-extent
Make extent for range [FROM, TO) in BUFFER -- BUFFER defaults to
current buffer.  Insertions at point TO will be outside of the extent;
insertions at FROM will be inside the extent (and the extent will grow.)

arguments:(from to &optional buffer)
Fdelete-extent
Remove EXTENT from its buffer; this does not modify the buffer's text,
only its display properties.

arguments:(extent_obj)
Fupdate-extent
Set the endpoints of EXTENT to START, END.

arguments:(extent_obj start end)
Fset-extent-attribute
Make EXTENT have ATTRIBUTE.
ATTRIBUTE must be one of the following symbols:

    highlight        highlight when the mouse moves over it
    write-protected    text within this extent will be unmodifyable
    invisible        don't display the text in this region
    unhighlight        turn off `highlight'
    writable        turn off `write-protected'
    visible        turn off `invisible'

arguments:(extent_obj attr)
Fextent-attributes
Return a list of attributes of EXTENT.
This list may contain any or none of the following symbols:

    highlight        highlight when the mouse moves over it
    write-protected    text within this extent will be unmodifyable
    invisible        don't display the text in this region
    begin-glyph        there is a begin-glyph
    end-glyph        there is an end-glyph
    detached        the text around the extent has been deleted

arguments:(extent_obj &optional raw_p)
Fset-extent-begin-glyph
Display a bitmap at the beginning of the given extent.
The begin-glyph should be a string naming a bitmap file (or nil.)

arguments:(extent_obj begin_glyph)
Fset-extent-end-glyph
Display a bitmap at the end of the given extent.
The end-glyph should be a string naming a bitmap file (or nil.)

arguments:(extent_obj end_glyph)
Fextent-data
Return the user data associated with the given extent.
Set this using the `set-extent-data' function.

arguments:(extent)
Fset-extent-data
Set the user data slot of the given extent.
Access this using the `extent-data' function.

arguments:(extent data)
Fextent-priority
Returns the display priority of EXTENT; see `set-extent-priority'.

arguments:(extent)
Fset-extent-priority
Changes the display priority of EXTENT.
When the extent attributes are being merged for display, the priority
is used to determine which extent takes precedence in the event of a
conflict (two extents whose faces both specify font, for example: the
font of the extent with the higher priority will be used.)
Extents are created with priority 0; priorities may be negative.

arguments:(extent pri)
Fextent-at
Find "smallest" extent at POS in BUFFER having FLAG set.  BUFFER
defaults to the current buffer, FLAG defaults to nil, meaning that any
extent will do. Possible values for FLAG are nil, 'menu, 'highlight,
'invisible, and 'write-protected. Returns nil if there is no matching
extent at POS.

arguments:(pos &optional buffer flag)
Fnext-extent
Find next extent after EXTENT. If EXTENT is a buffer
return the first extent in the buffer.

arguments:(extent_obj)
Fnext-e-extent
Find next extent after EXTENT using the "e" order. If
EXTENT is a buffer, return the first extent in the buffer.

arguments:(extent_obj)
Fstack-of-extents
Return stack of extents for BUFFER. Optional arg POSITION supplied
means compute the correct stack of extents for POSITION in BUFFER.

arguments:(buffer &optional position)
V   buffer-of-current-extent-fragment
Buffer for current extent fragment -- this is a GC hack.Fscreen-face-alist


arguments:(screen)
Fset-screen-face-alist


arguments:(screen value)
Fmake-face-internal


arguments:(name object id_number)
Fset-face-attribute-internal


arguments:(face_id attr_name attr_value screen)
Vmouse-highlight-priority
The priority to use for the mouse-highlighting pseudo-extent
that is used to highlight extents with the `highlight' attribute set.
See `set-extent-priority'.Ffile-name-directory
Return the directory component in file name NAME.
Return nil if NAME does not include a directory.
Otherwise return a directory spec.
Given a Unix or MS-DOS syntax file name, returns a string ending in slash;
on VMS, perhaps instead a string ending in `:', `]' or `>'.

arguments:(file)
Ffile-name-nondirectory
Return file name NAME sans its directory.
For example, in a Unix or MS-DOS syntax file name, this is everything
after the last slash, or the entire name if it contains no slash.

arguments:(file)
Ffile-name-as-directory
Return a string representing file FILENAME interpreted as a directory.
This operation exists because a directory is also a file, but its name as
a directory is different from its name as a file.
The result can be used as the value of `default-directory'
or passed as second argument to `expand-file-name'.
For a Unix or MS-DOS syntax file name, just appends a slash.
On VMS, converts "[X]FOO.DIR" to "[X.FOO]", etc.

arguments:(file)
Fdirectory-file-name
Returns the file name of the directory named DIR.
This is the name of the file that holds the data for the directory DIR.
This operation exists because a directory is also a file, but its name as
a directory is different from its name as a file.
In Unix or MS-DOS syntax, this function just removes the final slash.
On VMS, given a VMS-syntax directory name such as "[X.Y]",
it returns a file name such as "[X]Y.DIR.1".

arguments:(directory)
Fmake-temp-name
Generate temporary file name (string) starting with PREFIX (a string).
The Emacs process number forms part of the result,
so there is no danger of generating a name being used by another process.

arguments:(prefix)
Fexpand-file-name
Convert FILENAME to absolute, and canonicalize it.
Second arg DEFAULT is directory to start with if FILENAME is relative
 (does not start with slash); if DEFAULT is nil or missing,
the current buffer's value of default-directory is used.
Path components that are `.' are removed, and
path components followed by `..' are removed, along with the `..' itself;
note that these simplifications are done without checking the resulting
paths in the file system.
An initial `~/' expands to your home directory.
An initial `~USER/' expands to USER's home directory.
See also the function `substitute-in-file-name'.

Under MS-DOS, your home directory is determined by looking at
the environment variable HOME (defaulting to the root directory of C:),
and `~USER/' is not expanded.  In addition, the filename is converted
to lower-case and each section of the filename is truncated to the
maximum of 8 characters before a period and 3 after.  Invalid filenames
cause an error unless third arg NOERROR is non-nil, (in this case, nil
is returned).

arguments:(name &optional defalt noerror)
Ftruename
Returns the canonical name of the given FILE.
Second arg DEFAULT is directory to start with if FILE is relative
 (does not start with slash); if DEFAULT is nil or missing,
 the current buffer's value of default-directory is used.
No component of the resulting pathname will be a symbolic link, as
 in the realpath() function.
If the file does not exist, or is otherwise unable to be resolved,
 nil is returned.

arguments:(name &optional defalt)
Fsubstitute-in-file-name
Substitute environment variables referred to in FILENAME.
`$FOO' where FOO is an environment variable name means to substitute
the value of that variable.  The variable name should be terminated
with a character not a letter, digit or underscore; otherwise, enclose
the entire variable name in braces.
If `/~' appears, all of FILENAME through that `/' is discarded.

On VMS, `$' substitution is not done; this function does little and only
duplicates what `expand-file-name' does.

arguments:(string)
Fcopy-file
Copy FILE to NEWNAME.  Both args must be strings.
Signals a `file-already-exists' error if file NEWNAME already exists,
unless a third argument OK-IF-ALREADY-EXISTS is supplied and non-nil.
A number as third arg means request confirmation if NEWNAME already exists.
This is what happens in interactive use with M-x.
Fourth arg KEEP-TIME non-nil means give the new file the same
last-modified time as the old one.  (This works on only some systems.)
A prefix arg makes KEEP-TIME non-nil.

arguments:(filename newname &optional ok_if_already_exists keep_date)
Fmake-directory
Create a directory.  One argument, a file name string.

arguments:(dirname)
Fremove-directory
Remove a directory.  One argument, a file name string.

arguments:(dirname)
Fdelete-file
Delete specified file.  One argument, a file name string.
If file has multiple names, it continues to exist with the other names.

arguments:(filename)
Frename-file
Rename FILE as NEWNAME.  Both args strings.
If file has names other than FILE, it continues to have those names.
Signals a `file-already-exists' error if a file NEWNAME already exists
unless optional third argument OK-IF-ALREADY-EXISTS is non-nil.
A number as third arg means request confirmation if NEWNAME already exists.
This is what happens in interactive use with M-x.

arguments:(filename newname &optional ok_if_already_exists)
Fadd-name-to-file
Give FILE additional name NEWNAME.  Both args strings.
Signals a `file-already-exists' error if a file NEWNAME already exists
unless optional third argument OK-IF-ALREADY-EXISTS is non-nil.
A number as third arg means request confirmation if NEWNAME already exists.
This is what happens in interactive use with M-x.

Under MS-DOS, this function causes an error, because it is
not possible to give a file additional names.

arguments:(filename newname &optional ok_if_already_exists)
Fmake-symbolic-link
Make a symbolic link to FILENAME, named LINKNAME.  Both args strings.
Signals a `file-already-exists' error if a file NEWNAME already exists
unless optional third argument OK-IF-ALREADY-EXISTS is non-nil.
A number as third arg means request confirmation if NEWNAME already exists.
This happens for interactive use with M-x.

arguments:(filename newname &optional ok_if_already_exists)
Fdefine-logical-name
Define the job-wide logical name NAME to have the value STRING.
If STRING is nil or a null string, the logical name NAME is deleted.

arguments:(varname string)
Fsysnetunam
Open a network connection to PATH using LOGIN as the login string.

arguments:(path login)
Ffile-name-absolute-p
Return t if file FILENAME specifies an absolute path name.
On Unix, this is a name starting with a `/' or a `~'.
On MS-DOS, this also includes filenames beginning with a `\', and
names beginning with a drive specification (e.g. `C:') and followed
by a slash.

arguments:(filename)
Ffile-exists-p
Return t if file FILENAME exists.  (This does not mean you can read it.)
See also `file-readable-p' and `file-attributes'.

arguments:(filename)
Ffile-executable-p
Return t if FILENAME can be executed by you.
For directories this means you can change to that directory.

arguments:(filename)
Ffile-readable-p
Return t if file FILENAME exists and you can read it.
See also `file-exists-p' and `file-attributes'.

arguments:(filename)
Ffile-symlink-p
If file FILENAME is the name of a symbolic link
returns the name of the file to which it is linked.
Otherwise returns NIL.

On systems without symbolic links (e.g. MS-DOS), this function
always returns NIL.

arguments:(filename)
Ffile-writable-p
Return t if file FILENAME can be written or created by you.

arguments:(filename)
Ffile-directory-p
Return t if file FILENAME is the name of a directory as a file.
A directory name spec may be given instead; then the value is t
if the directory so specified exists and really is a directory.

arguments:(filename)
Ffile-modes
Return mode bits of FILE, as an integer.

arguments:(filename)
Fset-file-modes
Set mode bits of FILE to MODE (an integer).
Only the 12 low bits of MODE are used.

arguments:(filename mode)
Ffile-newer-than-file-p
Return t if file FILE1 is newer than file FILE2.
If FILE1 does not exist, the answer is nil;
otherwise, if FILE2 does not exist, the answer is t.

arguments:(file1 file2)
Finsert-file-contents
Insert contents of file FILENAME after point.
Returns list of absolute file name and length of data inserted.
If second argument VISIT is non-nil, the buffer's visited filename
and last save file modtime are set, and it is marked unmodified.
If visiting and the file does not exist, visiting is completed
before the error is signaled.

The optional third and fourth arguments BEG and END
specify what portion of the file to insert.
If VISIT is non-nil, BEG and END must be nil.
If optional fifth argument REPLACE is non-nil,
it means replace the current buffer contents (in the accessible portion)
with the file contents.  This is better than simply deleting and inserting
the whole thing because (1) it preserves some marker positions
and (2) it puts less data in the undo list.

arguments:(filename &optional visit beg end replace)
Fwrite-region
Write current region into specified file.
When called from a program, takes three arguments:
START, END and FILENAME.  START and END are buffer positions.
Optional fourth argument APPEND if non-nil means
  append to existing file contents (if any).
Optional fifth argument VISIT if t means
  set the last-save-file-modtime of buffer to this file's modtime
  and mark buffer not modified.
If VISIT is neither t nor nil, it means do not print
  the "Wrote file" message.
Kludgy feature: if START is a string, then that string is written
to the file, instead of any buffer contents, and END is ignored.

arguments:(start end filename &optional append visit)
Fencrypt-string
Encrypt STRING using KEY.

arguments:(string key)
Fdecrypt-string
Decrypt STRING using KEY.

arguments:(string key)
Fverify-visited-file-modtime
Return t if last mod time of BUF's visited file matches what BUF records.
This means that the file has not been changed since it was visited or saved.

arguments:(buf)
Fclear-visited-file-modtime
Clear out records of last mod time of visited file.
Next attempt to save will certainly not complain of a discrepancy.

arguments:()
Fset-visited-file-modtime
Update buffer's recorded modification time from the visited file's time.
Useful if the buffer was not read from the file normally
or if the file itself has been changed for some known benign reason.

arguments:()
Fset-buffer-modtime
Update BUFFER's recorded modification time from the associated
file's modtime, if there is an associated file. If not, use the
current time. In either case, if the optional arg TIME is supplied, use
that is it is either an integer or a cons of two integers.

arguments:(buf &optional in_time)
Fdo-auto-save
Auto-save all buffers that need it.
This is all buffers that have auto-saving enabled
and are changed since last auto-saved.
Auto-saving writes the buffer into a file
so that your editing is not lost if the system crashes.
This file is not the file you visited; that changes only when you save.

Non-nil first argument means do not print any message if successful.

arguments:(&optional nomsg)
Fset-buffer-auto-saved
Mark current buffer as auto-saved with its current text.
No auto-save file will be written until the buffer changes again.

arguments:()
Frecent-auto-save-p
Return t if buffer has been auto-saved since last read in or saved.

arguments:()
Vauto-compute-file-type-p
*Non-nil means file type (text or binary) will automatically be computed
from the file's extension.  See `file-name-file-type-alist'.Vvms-stmlf-recfm
*Non-nil means write new files with record format `stmlf'.
nil means use format `var'.  This variable is meaningful only on VMS.Vafter-insert-file-functions
A list of functions to be called at the end of `insert-file-contents'.
Each is passed one argument, the number of bytes inserted.  It should return
the new byte count, and leave point the same.  If `insert-file-contents' is
intercepted by a handler from `file-name-handler-alist', that handler is
responsible for calling the after-insert-file-functions if appropriate.Flock-buffer
Lock FILE, if current buffer is modified.
FILE defaults to current buffer's visited file,
or else nothing is done if current buffer isn't visiting a file.

arguments:(&optional fn)
Funlock-buffer
Unlock the file visited in the current buffer,
if it should normally be locked.

arguments:()
Ffile-locked-p
Return nil if the FILENAME is not locked,
t if it is locked by you, else a string of the name of the locker.

arguments:(&optional fn)
Vlock-directory
Don't change thisVsuperlock-path
Don't change thisFacos
Return the inverse cosine of ARG.

arguments:(arg)
Facosh
Return the inverse hyperbolic cosine of ARG.

arguments:(arg)
Fasin
Return the inverse sine of ARG.

arguments:(arg)
Fasinh
Return the inverse hyperbolic sine of ARG.

arguments:(arg)
Fatan
Return the inverse tangent of ARG.

arguments:(arg1 &optional arg2)
Fatanh
Return the inverse hyperbolic tangent of ARG.

arguments:(arg)
Fcos
Return the cosine of ARG.

arguments:(arg)
Fcosh
Return the hyperbolic cosine of ARG.

arguments:(arg)
Fcube-root
Return the cube root of ARG.

arguments:(arg)
Fexp
Return the exponential base e of ARG.

arguments:(arg)
Flog
Return the natural logarithm of ARG.
With two arguments, return the logarithm of ARG to the base ARG2.

arguments:(arg1 &optional arg2)
Flog10
Return the logarithm base 10 of ARG.

arguments:(arg)
Fexpt
Return the exponential x ** y.

arguments:(arg1 arg2)
Fsin
Return the sine of ARG.

arguments:(arg)
Fsinh
Return the hyperbolic sine of ARG.

arguments:(arg)
Fsqrt
Return the square root of ARG.

arguments:(arg)
Ftan
Return the tangent of ARG.

arguments:(arg)
Ftanh
Return the hyperbolic tangent of ARG.

arguments:(arg)
Fabs
Return the absolute value of ARG.

arguments:(arg)
Ffloat
Return the floating point number equal to ARG.

arguments:(arg)
Fceiling
Return the smallest integer no less than ARG.  (Round toward +inf.)

arguments:(arg)
Ffloor
Return the largest integer no greater than ARG.  (Round towards -inf.)

arguments:(arg)
Fround
Return the nearest integer to ARG.

arguments:(arg)
Ftruncate
Truncate a floating point number to an int.
Rounds the value toward zero.

arguments:(arg)
Ffceiling
Return the smallest integer no less than ARG, as a float.
(Round toward +inf.)

arguments:(arg)
Fffloor
Return the largest integer no greater than ARG, as a float.
(Round towards -inf.)

arguments:(arg)
Ffround
Return the nearest integer to ARG, as a float.

arguments:(arg)
Fftruncate
Truncate a floating point number to an integral float value.
Rounds the value toward zero.

arguments:(arg)
Fidentity
Return the argument unchanged.

arguments:(arg)
Frandom
Return a pseudo-random number.
On most systems all integers representable in Lisp are equally likely.
  This is 24 bits' worth.
With argument N, return random number in interval [0,N).
With argument t, set the random number seed from the current time and pid.

arguments:(&optional arg)
Flength
Return the length of vector, list or string SEQUENCE.
A byte-code function object is also allowed.

arguments:(obj)
Fstring-equal
T if two strings have identical contents.
Case is significant.
Symbols are also allowed; their print names are used instead.

arguments:(s1 s2)
Fstring-lessp
T if first arg string is less than second in lexicographic order.
Case is significant.
Symbols are also allowed; their print names are used instead.

arguments:(s1 s2)
Fappend
Concatenate all the arguments and make the result a list.
The result is a list whose elements are the elements of all the arguments.
Each argument may be a list, vector or string.
The last argument is not copied if it is a list.

arguments: (&rest args)
Fconcat
Concatenate all the arguments and make the result a string.
The result is a string whose elements are the elements of all the arguments.
Each argument may be a string, a list of numbers, or a vector of numbers.

arguments: (&rest args)
Fvconcat
Concatenate all the arguments and make the result a vector.
The result is a vector whose elements are the elements of all the arguments.
Each argument may be a list, vector or string.

arguments: (&rest args)
Fcopy-sequence
Return a copy of a list, vector or string.
The elements of a list or vector are not copied; they are shared
with the original.

arguments:(arg)
Fcopy-alist
Return a copy of ALIST.
This is an alist which represents the same mapping from objects to objects,
but does not share the alist structure with ALIST.
The objects mapped (cars and cdrs of elements of the alist)
are shared, however.

arguments:(alist)
Fcopy-tree
Return a copy of a list or vector, and substructures.
The argument is copied, and any lists or vectors contained within it
are copied recursively.  Circularities and shared substructures are
not preserved.  Strings are not copied.

arguments:(arg)
Fsubstring
Return a substring of STRING, starting at index FROM and ending before TO.
TO may be nil or omitted; then the substring runs to the end of STRING.
If FROM or TO is negative, it counts from the end.

arguments:(string from &optional to)
Fnthcdr
Take cdr N times on LIST, returns the result.

arguments:(n list)
Fnth
Return the Nth element of LIST.
N counts from zero.  If LIST is not that long, nil is returned.

arguments:(n list)
Felt
Return element of SEQUENCE at index N.

arguments:(seq n)
Fmember
Return non-nil if ELT is an element of LIST.  Comparison done with EQUAL.
The value is actually the tail of LIST whose car is ELT.

arguments:(elt list)
Fmemq
Return non-nil if ELT is an element of LIST.  Comparison done with EQ.
The value is actually the tail of LIST whose car is ELT.

arguments:(elt list)
Fassq
Return non-nil if ELT is `eq' to the car of an element of LIST.
The value is actually the element of LIST whose car is ELT.

arguments:(key list)
Fassoc
Return non-nil if ELT is `equal' to the car of an element of LIST.
The value is actually the element of LIST whose car is ELT.

arguments:(key list)
Frassq
Return non-nil if ELT is `eq' to the cdr of an element of LIST.
The value is actually the element of LIST whose cdr is ELT.

arguments:(key list)
Fdelq
Delete by side effect any occurrences of ELT as a member of LIST.
The modified LIST is returned.  Comparison is done with `eq'.
If the first member of LIST is ELT, there is no way to remove it by side effect;
therefore, write `(setq foo (delq element foo))'
to be sure of changing the value of `foo'.

arguments:(elt list)
Fdelete
Delete by side effect any occurrences of ELT as a member of LIST.
The modified LIST is returned.  Comparison is done with `equal'.
If the first member of LIST is ELT, there is no way to remove it by side effect;
therefore, write `(setq foo (delete element foo))'
to be sure of changing the value of `foo'.

arguments:(elt list)
Fnreverse
Reverse LIST by modifying cdr pointers.
Returns the beginning of the reversed list.

arguments:(list)
Freverse
Reverse LIST, copying.  Returns the beginning of the reversed list.
See also the function `nreverse', which is used more often.

arguments:(list)
Fsort
Sort LIST, stably, comparing elements using PREDICATE.
Returns the sorted list.  LIST is modified by side effects.
PREDICATE is called with two elements of LIST, and should return T
if the first element is "less" than the second.

arguments:(list pred)
Fget
Return the value of SYMBOL's PROPNAME property.
This is the last VALUE stored with `(put SYMBOL PROPNAME VALUE)'.

arguments:(sym prop)
Fput
Store SYMBOL's PROPNAME property with value VALUE.
It can be retrieved with `(get SYMBOL PROPNAME)'.

arguments:(sym prop val)
Fremprop
Remove from SYMBOL's plist the property PROP and its value.

arguments:(symbol property)
Fequal
T if two Lisp objects have similar structure and contents.
They must have the same data type.
Conses are compared by comparing the cars and the cdrs.
Vectors and strings are compared element by element.
Numbers are compared by value.  Symbols must match exactly.

arguments:(o1 o2)
Ffillarray
Store each element of ARRAY with ITEM.  ARRAY is a vector or string.

arguments:(array item)
Fnconc
Concatenate any number of lists by altering them.
Only the last argument is not altered, and need not be a list.

arguments: (&rest args)
Fmapconcat
Apply FN to each element of SEQ, and concat the results as strings.
In between each pair of results, stick in SEP.
Thus, " " as SEP results in spaces between the values return by FN.

arguments:(fn seq sep)
Fmapcar
Apply FUNCTION to each element of SEQUENCE, and make a list of the results.
The result is a list just as long as SEQUENCE.
SEQUENCE may be a list, a vector or a string.

arguments:(fn seq)
Fload-average
Return list of 1 minute, 5 minute and 15 minute load averages.
Each of the three load averages is multiplied by 100,
then converted to integer.

This won't work unless the emacs executable is setgid kmem
(assuming that /dev/kmem is in the group kmem.)

arguments:()
Ffeaturep
Returns t if FEATURE is present in this Emacs.
Use this to conditionalize execution of lisp code based on the presence or
absence of emacs or environment extensions.
Use `provide' to declare that a feature is available.
This function looks at the value of the variable `features'.

arguments:(feature)
Fprovide
Announce that FEATURE is a feature of the current Emacs.

arguments:(feature)
Frequire
If feature FEATURE is not loaded, load it from FILENAME.
If FEATURE is not a member of the list `features', then the feature
is not loaded; so load the file FILENAME.
If FILENAME is omitted, the printname of FEATURE is used as the file name.

arguments:(feature &optional file_name)
Fplay-sound-file
Play the named sound file on the console speaker at the specified volume
(0-100, default specified by the `bell-volume' variable).
The sound file must be in the Sun/NeXT U-LAW format.

arguments:(file &optional vol)
Fplay-sound
Play a sound of the provided type.
See the variable sound-alist.

arguments:(sound &optional volume)
Vfeatures
A list of symbols which are the features of the executing emacs.
Used by `featurep' and `require', and altered by `provide'.Vbell-volume
How loud to be, from 0 to 100.Vsound-alist
An alist associating symbols with strings of audio-data.
When `beep' or `ding' is called with one of the symbols, the associated
sound data will be played instead of the standard beep.  This only works
if you are logged in on the console of a Sun SparcStation or SGI machine.

Elements of this list should be of one of the following forms:

   ( symbol . string-or-symbol )
   ( symbol integer string-or-symbol )

If the `string-or-symbol' is a string, then it should contain raw sound data,
the contents of a `.au' file.  If it is a symbol, then that means that this
element is an alias for some other element, and the sound-player will look
for that next.  If the integer is provided, it is the volume at which the
sound should be played, from 0 to 100.

If an element of this alist begins with the symbol `default', then that sound
will be used when no other sound is appropriate.

The symbol `t' in place of a sound-string means to use the default X beep.
In this way, you can define beep-types to have different volumes even when
not running on the console of a Sun4.

You should probably add things to this list by calling the function
load-sound-file.

The following beep-types are used by emacs itself:

    auto-save-error    when an auto-save does not succeed
    command-error    when the emacs command loop catches an error
    undefined-key    when you type a key that is undefined
    undefined-click    when you use an undefined mouse-click combination
    no-completion    during completing-read
    y-or-n-p        when you type something other than 'y' or 'n'
    yes-or-no-p      when you type something other than 'yes' or 'no'

Other lisp packages may use other beep types, but these are the ones that
the C kernel of emacs uses.Fbuffer-syntactic-context-flush-cache
Flush the cache used by `buffer-syntactic-context-flush-cache'.
Call this when deletions occur.  This is a kludge.

arguments:()
Fbuffer-syntactic-context
Returns the syntactic context of the current buffer at point.
The returned value is one of the following symbols:

    nil        ; meaning no special interpretation
    string        ; meaning point is within a string
    comment        ; meaning point is within a line comment
    block-comment    ; meaning point is within a block comment

See also the function `buffer-syntactic-context-depth', which returns
the current nesting-depth within all parenthesis-syntax delimiters
and the function `syntactically-sectionize', which will map a function
over each syntactic context in a region.

Warning, this may alter match-data.

arguments:()
Fbuffer-syntactic-context-depth
Returns the depth within all parenthesis-syntax delimiters at point.
Warning, this may alter match-data.

arguments:()
Fsyntactically-sectionize
Creates extents for each contiguous syntactic context in the region.
Calls the given function when each extent is created with three arguments:
the extent, a symbol representing the syntactic context, and the current
depth (as returned by the functions `buffer-syntactic-context' and
`buffer-syntactic-context-depth').  If the optional arg `extent-data' is
provided, the extent will be created with that in its data slot.

Warning, this may alter match-data.

arguments:(start end function &optional extent_data)
Fcurrent-column
Return the horizontal position of point.  Beginning of line is column 0.
This is calculated by adding together the widths of all the displayed
representations of the character between the start of the previous line
and point.  (eg control characters will have a width of 2 or 4, tabs
will have a variable width)
Ignores finite width of screen, which means that this function may return
values greater than (screen-width).
Whether the line is visible (if `selective-display' is t) has no effect;
however, ^M is treated as end of line when `selective-display' is t.

arguments:()
Findent-to
Indent from point with tabs and spaces until COLUMN is reached.
Optional second argument MIN says always do at least MIN spaces
even if that goes past COLUMN; by default, MIN is zero.

arguments:(col &optional minimum)
Fcurrent-indentation
Return the indentation of the current line.
This is the horizontal position of the character
following any initial whitespace.

arguments:()
Fmove-to-column
Move point to column COLUMN in the current line.
The column of a character is calculated by adding together the widths
as displayed of the previous characters in the line.
This function ignores line-continuation;
there is no upper limit on the column number a character can have
and horizontal scrolling has no effect.

If specified column is within a character, point goes after that character.
If it's past end of line, point goes to end of line.

A non-nil second (optional) argument FORCE means, if the line
is too short to reach column COLUMN then add spaces/tabs to get there,
and if COLUMN is in the middle of a tab character, change it to spaces.

arguments:(column &optional force)
Fmotion
Move forward from point by N characters.  Stop if we reach
TOHPOS, TOVPOS first.

arguments:(n tohpos tovpos)
Fvertical-motion
Move to start of screen line LINES lines down.
If LINES is negative, this is moving up.
Sets point to position found; this may be start of line
 or just the start of a continuation line.
Returns number of lines moved; may be closer to zero than LINES
 if beginning or end of buffer was reached.
Optional second argument is WINDOW to move in.

arguments:(lines &optional window)
Vindent-tabs-mode
*Indentation can insert tabs if this is non-nil.
Setting this variable automatically makes it local to the current buffer.Frecursive-edit
Invoke the editor command loop recursively.
To get out of the recursive edit, a command can do `(throw 'exit nil)';
that tells this function to return.
Alternately, `(throw 'exit t)' makes this function signal an error.
This function is called by the editor initialization to begin editing.

arguments:()
Ftop-level
Exit all recursive editing levels.

arguments:()
Fexit-recursive-edit
Exit from the innermost recursive edit or minibuffer.

arguments:()
Fabort-recursive-edit
Abort the command that requested this recursive edit or minibuffer input.

arguments:()
Fcommand-execute
Execute CMD as an editor command.
CMD must be a symbol that satisfies the `commandp' predicate.
Optional second arg RECORD-FLAG non-nil
means unconditionally put this command in `command-history'.
Otherwise, that is done only if an arg is read using the minibuffer.

arguments:(cmd &optional record)
Frecent-keys
Return vector of last 100 keyboard or mouse button events read.
This copies 100 event objects and a vector; it is safe to keep and modify
them.

arguments:()
Fthis-command-keys
Returns a vector of the keyboard or mouse button events that were used
to invoke this command.  This copies the vector and the events; it is safe
to keep and modify them.

arguments:()
Frecursion-depth
Return the current depth in recursive edits.

arguments:()
Fopen-dribble-file
Start writing all keyboard characters to FILE.

arguments:(file)
Fsuspend-emacs
Stop Emacs and return to superior process.  You can resume later.
If optional arg STUFFSTRING is non-nil, its characters are stuffed
to be read as terminal input by Emacs's superior shell.
Before suspending, if `suspend-hook' is bound and value is non-nil
call the value as a function of no args.  Don't suspend if it returns non-nil.
Otherwise, suspend normally and after resumption call
`suspend-resume-hook' if that is bound and non-nil.

arguments:(&optional stuffstring)
Fset-input-mode
Set mode of reading keyboard input.
First arg non-nil means use input interrupts; nil means use CBREAK mode.
Second arg non-nil means use ^S/^Q flow control for output to terminal
 (no effect except in CBREAK mode).
Third arg non-nil means accept 8-bit input (for a Meta key).
 Otherwise, the top bit is ignored, on the assumption it is parity.

arguments:(intrrupt flow meta)
Fset-interrupt-character
Change the interrupt character.  Arg is an ASCII code or nil.
Among other system-dependent things, this changes the value of the
variable `interrupt-char'.

arguments:(new_interrupt_char)
Vdisabled-command-hook
Value is called instead of any command that is disabled,
i.e. has a non-nil `disabled' property.Vlast-command-event
Last keyboard or mouse button event that was part of a command.  This
variable is off limits: you may not set its value or modify the event that
is its value, as it is destructively modified by `read-key-sequence'.  If
you want to keep a pointer to this value, you must use `copy-event'.Vlast-command-char
If the value of `last-command-event' is a keyboard event, then
this is the nearest ASCII equivalent to it.  This the the value that
`self-insert-command' will put in the buffer.  Remember that there is
NOT a 1:1 mapping between keyboard events and ASCII characters: the set
of keyboard events is much larger, so writing code that examines this
variable to determine what key has been typed is bad practice, unless
you are certain that it will be one of a small set of characters.Vlast-input-event
Last keyboard or mouse button event recieved.  This variable is off
limits: you may not set its value or modify the event that is its value, as
it is destructively modified by `next-event'.  If you want to keep a pointer
to this value, you must use `copy-event'.Vlast-input-char
If the value of `last-input-event' is a keyboard event, then
this is the nearest ASCII equivalent to it.  Remember that there is
NOT a 1:1 mapping between keyboard events and ASCII characters: the set
of keyboard events is much larger, so writing code that examines this
variable to determine what key has been typed is bad practice, unless
you are certain that it will be one of a small set of characters.Vlast-input-time
The time (in seconds since Jan 1, 1970) of the last-command-event,
represented as a cons of two 16-bit integers.  This is destructively
modified, so copy it if you want to keep it.Vunread-command-event
Set this to an event object to simulate the reciept of an event from
the user.  Normally this is nil.Vlast-command
The last command executed.  Normally a symbol with a function definition,
but can be whatever was found in the keymap, or whatever the variable
`this-command' was set to by that command.Vthis-command
The command now being executed.
The command can set this variable; whatever is put here
will be in `last-command' during the following command.Vhelp-char
Character to recognize as meaning Help.
When it is read, do `(eval help-form)', and display result if it's a string.
If the value of `help-form' is nil, this char can be read normally.Vinterrupt-char
Character which interrupts emacs.
Do not setq this variable: use the function `set-interrupt-character' instead.
Depending on the system you are on, this may need to do magic like changing
interrupt handlers.Vhelp-form
Form to execute when character help-char is read.
If the form returns a string, that string is displayed.
If `help-form' is nil, the help char is not recognized.Vpre-command-hook
Function or functions to run before every command.
This may examine the `this-command' variable to find out what command
is about to be run, or may change it to cause a different command to run.
Function on this hook must be careful to avoid signalling errors!Vpost-command-hook
Function or functions to run after every command.
This may examine the `this-command' variable to find out what command
was just executed.Vtop-level
Form to evaluate when Emacs starts up.
Useful to set before you dump a modified Emacs.Vkeyboard-translate-table
String used as translate table for keyboard input, or nil.
Each character is looked up in this string and the contents used instead.
If string is of length N, character codes N and up are untranslated.
This is the right thing to use only if you are on a dumb tty, as it cannot
handle input which cannot be represented as ASCII.  If you are running emacs
under X, you should do the translations with the `xmodmap' program instead.Fmake-keymap
Construct and return a new keymap object.  All entries in it are nil,
meaning "command undefined".

arguments:()
Fmake-sparse-keymap
Construct and return a new keymap object.  All entries in it are nil,
meaning "command undefined".  The only difference between this function
and make-keymap is that this function returns a "smaller" keymap (one
that is expected to contain less entries.)  As keymaps dynamically resize,
the distinction is not great.

arguments:()
Fkeymap-parent
Returns the `parent' keymap of the given keymap, or nil.
The parent of a keymap is searched for keybindings when a key sequence
isn't bound in this one.  The (current-global-map) is the default parent
of all keymaps.

arguments:(keymap)
Fset-keymap-parent
Sets the `parent' keymap of the given keymap.
The parent of a keymap is searched for keybindings when a key sequence
isn't bound in this one.  The (current-global-map) is the default parent
of all keymaps.

arguments:(keymap parent)
Fset-keymap-name
Sets the `name' of the KEYMAP to NEW-NAME
The name is only a debugging convenience; it is not used except
when printing the keymap.

arguments:(keymap new_name)
Fkeymapp
Return t if ARG is a keymap object.

arguments:(object)
Fcopy-keymap
Return a copy of the keymap KEYMAP.
The copy starts out with the same definitions of KEYMAP,
but changing either the copy or KEYMAP does not affect the other.
Any key definitions that are subkeymaps are recursively copied.

arguments:(keymap)
Fkeymap-fullness
Returns the number of bindings in the keymap.

arguments:(keymap)
Fdefine-key
Args KEYMAP, KEYS, DEF.  Define key sequence KEYS, in KEYMAP, as DEF.
KEYMAP is a keymap object.
KEYS is the sequence of keystrokes to bind, described below.
DEF is anything that can be a key's definition:
 nil (means key is undefined in this keymap);
 a command (a Lisp function suitable for interactive calling);
 a string or key sequence vector (treated as a keyboard macro);
 a keymap (to define a prefix key);
 a symbol; when the key is looked up, the symbol will stand for its
    function definition, that should at that time be one of the above,
    or another symbol whose function definition is used, and so on.
 a cons (STRING . DEFN), meaning that DEFN is the definition
    (DEFN should be a valid definition in its own right);
 or a cons (KEYMAP . CHAR), meaning use definition of CHAR in map KEYMAP.

Contrary to popular belief, the world is not ASCII.  When running under a
window manager, Emacs can tell the difference between, for example, the
keystrokes control-h, control-shift-h, and backspace.  You can, in fact,
bind different commands to each of these.

A `key sequence' is a set of keystrokes.  A `keystroke' is a keysym and some
set of modifiers (such as control and meta).  A `keysym' is what is printed
on the keys on your keyboard.

A keysym may be represented by a symbol, or (if and only if it is equivalent
to a printing ASCII character) by its ASCII code.  The `A' key may be
represented by the symbol `A' or by the number 65.  The `break' key may be
represented only by the symbol `break'.

A keystroke may be represented by a list: the last element of the list is
the key (a symbol or number, as above) and the preceding elements are the
symbolic names of modifier keys (control, meta, super, hyper, and shift.)
Thus, the sequence control-b is represented by the forms `(control b)'
and `(control 98)'.  A keystroke may also be represented by an event object,
as returned by the `next-command-event' and `read-key-sequence' functions.

Note that in this context, the keystroke `control-b' is *not* represented
by the number 2 (the ASCII code for ^B).  See below.

The `shift' modifier is somewhat of a special case.  You should not (and
cannot) use `(meta shift a)' to mean `(meta A)', since for characters that
have printing ASCII equivalents, the state of the shift key is implicit in
the keysym (a vs. A).  You also cannot say `(shift =)' to mean `+', as that
sort of thing varies from keyboard to keyboard.  The shift modifier is for
use only with characters that do not have a second keysym on the same key,
such as `backspace' and `tab'.

A key sequence is a vector of keystrokes.  As a degenerate case, elements
of this vector may also be keysyms if they have no modifiers.  That is,
the `A' keystroke is represented by all of these forms:
    A    65    (A)    (65)    [A]    [65]    [(A)]    [(65)]
the `control-a' keystroke is represented by these forms:
    (control A)    (control 65)    [(control A)]    [(control 65)]
the key sequence `control-c control-a' is represented by these forms:
    [(control c) (control a)]    [(control 99) (control 65)]

Mouse button clicks work just like keypresses: (control button1) means
pressing the left mouse button while holding down the control key.
[(control c) (shift button3)] means control-c, hold shift, click right.

Commands may be bound to the mouse-button up-stroke rather than the down-
stroke as well.  `button1' means the down-stroke, and `button1up' means the
up-stroke.  Different commands may be bound to the up and down strokes,
though that is probably not what you want, so be careful.

For backward compatibility, a key sequence may also be represented by a
string.  In this case, it represents the key sequence(s) that would
produce that sequence of ASCII characters in a purely ASCII world.  For
example, a string containing the ASCII backspace character, "\^H", would
represent two key sequences: `(control h)' and `backspace'.  Binding a
command to this will actually bind both of those key sequences.  Likewise
for the following pairs:

        control h    backspace
        control i       tab
        control m       return
        control j       linefeed
        control [       escape
        control @    control space

After binding a command to two key sequences with a form like

    (define-key global-map "\^X\^I" 'command-1)

it is possible to redefine only one of those sequences like so:

    (define-key global-map [(control x) (control i)] 'command-2)
    (define-key global-map [(control x) tab] 'command-3)

Of course, all of this applies only when running under a window system.  If
you're talking to emacs through an ASCII-only channel, you don't get any of
these features.

arguments:(keymap keys def)
Flookup-key
In keymap KEYMAP, look up key sequence KEYS.  Return the definition.
nil means undefined.  See doc of `define-key' for kinds of definitions
and key-sequence specifications.
Number as value means KEYS is "too long";
that is, characters in it except for the last one
fail to be a valid sequence of prefix characters in KEYMAP.
The number is how many characters at the front of KEYS
it takes to reach a non-prefix command.

arguments:(keymap keys)
Fkey-binding
Return the binding for command KEYS in current keymaps.
KEYS is a string, a vector of events, or a vector of key-description lists
as described in the documentation for the `define-key' function.
The binding is probably a symbol with a function definition.

arguments:(keys)
Fuse-global-map
Select KEYMAP as the global keymap.

arguments:(keymap)
Fuse-local-map
Select KEYMAP as the local keymap.
If KEYMAP is nil, that means no local keymap.

arguments:(keymap)
Fcurrent-local-map
Return current buffer's local keymap, or nil if it has none.

arguments:()
Fcurrent-global-map
Return the current global keymap.

arguments:()
Fmap-keymap
Apply FUNCTION to each element of KEYMAP.  FUNCTION will be called with
two arguments: a key-description list, and the binding.  The order in which
the elements of the keymap are passed to the function is unspecified.  If
the function inserts new elements into the keymap, it may or may not
be called with them later.  No element of the keymap will ever be passed to
the function more than once.

The function will not be called on elements of this keymap's parent (see the
function `keymap-parent') or upon keymaps which are contained within this
keymap (multi-character definitions).  It will be called on "meta"
characters, however, since they are not really two-character sequences.

If the optional third argument SORT-FIRST is non-nil, then the elements of
the keymap will be passed to the mapper function in a canonical order.
Otherwise, they will be passed in hash (that is, random) order, which is
faster.

arguments:(function keymap &optional sort_first)
Faccessible-keymaps
Find all keymaps accessible via prefix characters from KEYMAP.
Returns a list of elements of the form (KEYS . MAP), where the sequence
KEYS starting from KEYMAP gets you to MAP.  These elements are ordered
so that the KEYS increase in length.  The first element is ([] . KEYMAP).

arguments:(startmap)
Fkey-description
Return a pretty description of key-sequence KEYS.
Control characters turn into "C-foo" sequences, meta into "M-foo"
spaces are put between sequence elements, etc.

arguments:(keys)
Fsingle-key-description
Return a pretty description of command character KEY.
Control characters turn into C-whatever, etc.

arguments:(key)
Ftext-char-description
Return a pretty description of file-character CHAR.
Control characters turn into "^char", etc.

arguments:(chr)
Fwhere-is-internal
Return list of keys that invoke DEFINITION in optional 2nd argument KEYMAP
or optional 4th argument GLOBAL_KEYMAP.
If KEYMAP is nil, search only GLOBAL_KEYMAP.
If GLOBAL_KEYMAP is nil, use the current global map.

If optional 3rd arg FIRSTONLY is non-nil,
return the first key sequence found, rather than a list of all possible
key sequences.

arguments:(definition &optional local_keymap firstonly global_keymap noindirect)
Fdescribe-bindings
Show a list of all defined keys, and their definitions.
The list is put in a buffer, which is displayed.
If the argument is non-null, then only the mouse bindings are displayed.

arguments:(&optional mice_only_p)
Fapropos-internal
Show all symbols whose names contain match for REGEXP.
If optional 2nd arg PRED is non-nil, (funcall PRED SYM) is done
for each symbol and a symbol is mentioned only if that returns non-nil.
Return list of symbols found.

arguments:(string &optional pred)
Vmeta-prefix-char
Meta-prefix character code.  Must be an ASCII integer.
This character followed by some character `foo' turns into `Meta-foo'.
To disable the meta-prefix-char, set it to a negative number.Vkeymap-tick
Incremented for each change to any keymap.Fread-char


arguments:()
Fget-file-char
Don't use this yourself.

arguments:()
Fload
Execute a file of Lisp code named FILE.
First try FILE with `.elc' appended, then try with `.el',
 then try FILE unmodified.
This function searches the directories in `load-path'.
If optional second arg MISSING-OK is non-nil,
 report no error if FILE doesn't exist.
Print messages at start and end of loading unless
 optional third arg NOMESSAGE is non-nil.
If optional fourth arg NOSUFFIX is non-nil, don't try adding
 suffixes `.elc' or `.el' to the specified name FILE.
Return t if file exists.

arguments:(str &optional missing_ok nomessage nosuffix)
Flocate-file
Search for FILENAME through PATH-LIST, expanded by one of the optional
SUFFIXES (string of suffixes separated by ":"s), checking for access
MODE (0|1|2|4 = exists|executable|writeable|readable), default readable.

arguments:(file path &optional suff mode)
Feval-buffer
Execute BUFFER as Lisp code.
Programs can pass argument PRINTFLAG which controls printing of output:
nil means discard it; anything else is stream for print.

arguments:(bufname &optional printflag)
Feval-region
Execute the region as Lisp code.
When called from programs, expects two arguments,
giving starting and ending indices in the current buffer
of the text to be executed.
Programs can pass third argument PRINTFLAG which controls output:
nil means discard it; anything else is stream for printing it.

If there is no error, point does not move.  If there is an error,
point remains at the end of the last character read from the buffer.

arguments:(b e &optional printflag)
Fread
Read one Lisp expression as text from STREAM, return as Lisp object.
If STREAM is nil, use the value of `standard-input' (which see).
STREAM or the value of `standard-input' may be:
 a buffer (read from point and advance it)
 a marker (read from where it points and advance it)
 a function (call it with no arguments for each character,
     call it with a char as argument to push a char back)
 a string (takes text from string, starting at the beginning)
 t (read text line using minibuffer and use it).

arguments:(&optional readcharfun)
Fread-from-string
Read one Lisp expression which is represented as text by STRING.
Returns a cons: (OBJECT-READ . FINAL-STRING-INDEX).
START and END optionally delimit a substring of STRING from which to read;
 they default to 0 and (length STRING) respectively.

arguments:(string &optional start end)
Fintern
Return the canonical symbol whose name is STRING.
If there is none, one is created by this function and returned.
A second optional argument specifies the obarray to use;
it defaults to the value of `obarray'.

arguments:(str &optional obarray)
Fintern-soft
Return the canonical symbol whose name is STRING, or nil if none exists.
A second optional argument specifies the obarray to use;
it defaults to the value of `obarray'.

arguments:(str &optional obarray)
Fmapatoms
Call FUNCTION on every symbol in OBARRAY.
OBARRAY defaults to the value of `obarray'.

arguments:(function &optional obarray)
Vobarray
Symbol table for use by `intern' and `read'.
It is a vector whose length ought to be prime for best results.
The vector's contents don't make sense if examined from Lisp programs;
to find all the symbols in an obarray, use `mapatoms'.Vvalues
List of values of all expressions which were read, evaluated and printed.
Order is reverse chronological.Vstandard-input
Stream for read to get input from.
See documentation of `read' for possible values.Vload-path
*List of directories to search for files to load.
Each element is a string (directory name) or nil (try default directory).

Note that the elements of this list *may not* begin with "~", so you must
call `expand-file-name' on them before adding them to this list.

Initialized based on EMACSLOADPATH environment variable, if any,
otherwise to default specified in by file `paths.h' when Emacs was built.
If there were no paths specified in `paths.h', then emacs chooses a default
value for this variable by looking around in the file-system near the
directory in which the emacs executable resides.Vload-in-progress
Non-nil iff inside of `load'.Vafter-load-alist
An alist of expressions to be evalled when particular files are loaded.
Each element looks like (FILENAME FORMS...).
When `load' is run and the file-name argument is FILENAME,
the FORMS in the corresponding element are executed at the end of loading.

FILENAME must match exactly!  Normally FILENAME is the name of a library,
with no directory specified, since that is how `load' is normally called.
An error in FORMS does not undo the load,
but does prevent execution of the rest of the FORMS.Vload-warn-when-source-newer
*Whether `load' should check whether the source is newer than the binary;
If this variable is true, then when a `.elc' file is being loaded and the
corresponding `.el' is newer, a warning message will be printed.Vload-warn-when-source-only
*Whether `load' should warn when loading a .el file instead of an .elc.
If this variable is true, then when load is called with a filename without
an extension, and the .elc version doesn't exist but the .el version does,
then a message will be printed.  If an explicit extension is passed to load,
no warning will be printed.Fstart-kbd-macro
Record subsequent keyboard and menu input, defining a keyboard macro.
The commands are recorded even as they are executed.
Use \[end-kbd-macro] to finish recording and make the macro available.
Use \[name-last-kbd-macro] to give it a permanent name.
Non-nil arg (prefix arg) means append to last macro defined;
 This begins by re-executing that macro as if you typed it again.

arguments:(append)
Fend-kbd-macro
Finish defining a keyboard macro.
The definition was started by \[start-kbd-macro].
The macro is now available for use via \[call-last-kbd-macro],
or it can be given a name with \[name-last-kbd-macro] and then invoked
under that name.

With numeric arg, repeat macro now that many times,
counting the definition just completed as the first repetition.
An argument of zero means repeat until error.

arguments:(&optional arg)
Fcall-last-kbd-macro
Call the last keyboard macro that you defined with \[start-kbd-macro].

A prefix argument serves as a repeat count.  Zero means repeat until error.

To make a macro permanent so you can call it even after
defining others, use \[name-last-kbd-macro].

arguments:(&optional prefix)
Fexecute-kbd-macro
Execute MACRO as string of editor command characters.
If MACRO is a symbol, its function definition is used.
COUNT is a repeat count, or nil for once, or 0 for infinite loop.

arguments:(macro &optional prefixarg)
Vdefining-kbd-macro
Non-nil while a keyboard macro is being defined.  Don't set this!Vexecuting-macro
Currently executing keyboard macro (a vector of events);
nil if none executing.Vexecuting-kbd-macro
Currently executing keyboard macro (a vector of events);
nil if none executing.Vlast-kbd-macro
Last kbd macro defined, as a vector of events; nil if none defined.Fmarker-buffer
Return the buffer that MARKER points into, or nil if none.
Returns nil if MARKER points into a dead buffer.

arguments:(marker)
Fmarker-position
Return the position MARKER points at, as a character number.

arguments:(marker)
Fset-marker
Position MARKER before character number NUMBER in BUFFER.
BUFFER defaults to the current buffer.
If NUMBER is nil, makes marker point nowhere.
Then it no longer slows down editing in any buffer.
If this marker was returned by (point-marker t), then changing its position
moves point.  You cannot change its buffer or make it point nowhere.
Returns MARKER.

arguments:(marker pos &optional buffer)
Fcopy-marker
Return a new marker pointing at the same place as MARKER.
If argument is a number, makes a new marker pointing
at that position in the current buffer.

arguments:(marker)
Fset-menubar-dirty-flag
Tells emacs that the menubar widget has to be updated

arguments:()
Fpopup-menu
Pop up the given menu.
A menu description is a list of menu items, strings, and submenus.

The first element of a menu must be a string, which is the name of the
menu.  This is the string that will be displayed in the parent menu, if
any.  For toplevel menus, it is ignored.  This string is not displayed
in the menu itself.

A menu item is a vector of three or four elements:

 - the name of the menu item (a string);
 - the `callback' of that item;
 - whether this item is active (selectable);
 - and an optional string to append to the name.

If the `callback' of a menu item is a symbol, then it must name a command.
It will be invoked with `call-interactively'.  If it is a list, then it is
evaluated with `eval'.

The fourth element of a menu item is a convenient way of adding the name
of a command's ``argument'' to the menu, like ``Kill Buffer NAME''.

If an element of a menu is a string, then that string will be presented in
the menu as unselectable text.

If an element of a menu is a string consisting solely of hyphens, then that
item will be presented as a solid horizontal line.

If an element of a menu is a list, it is treated as a submenu.  The name of
that submenu (the first element in the list) will be used as the name of the
item representing this menu on the parent.

The syntax, more precisely:

   form        :=  <something to pass to `eval'>
   command    :=  <a symbol or string, to pass to `call-interactively'>
   callback     :=  command | form
   active-p    :=  <t or nil, whether this thing is selectable>
   text        :=  <string, non selectable>
   name        :=  <string>
   argument    :=  <string>
   menu-item    :=  '['  name callback active-p [ argument ]  ']'
   menu        :=  '(' name [ menu-item | menu | text ]+ ')'

arguments:(menu_desc)
Fpopup-menu-up-p
Returns T if a popup menu is up, NIL otherwise.
See popup-menu.

arguments:()
Fpopup-dialog-box
Pop up a dialog box.
A dialog box description is a list.

 - The first element of the list is a string to display in the dialog box.
 - The rest of the elements are descriptions of the dialog box's buttons.
   Each one is a vector of three elements:
   - The first element is the text of the button.
   - The second element is the `callback'.
   - The third element is t or nil, whether this button is selectable.

If the `callback' of a button is a symbol, then it must name a command.
It will be invoked with `call-interactively'.  If it is a list, then it is
evaluated with `eval'.

One (and only one) of the buttons may be `nil'.  This marker means that all
following buttons should be flushright instead of flushleft.

The syntax, more precisely:

   form        :=  <something to pass to `eval'>
   command    :=  <a symbol or string, to pass to `call-interactively'>
   callback     :=  command | form
   active-p    :=  <t or nil, whether this thing is selectable>
   name        :=  <string>
   partition    :=  'nil'
   button    :=  '['  name callback active-p ']'
   dialog    :=  '(' name [ button ]+ [ partition [ button ]+ ] ')'

arguments:(dbox_desc)
Vcurrent-menubar
The current menubar.  This may be buffer-local.

When the menubar is changed, the function `set-menubar-dirty-flag' has to
be called for the menubar to be updated on the screen.  See `set-menubar'
and `set-buffer-menubar'.

A menubar is a list of menus and menu-items.
A menu is a list of menu items, strings, and submenus.

The first element of a menu must be a string, which is the name of the
menu.  This is the string that will be displayed in the menubar, or in
the parent menu.  This string is not displayed in the menu itself.

A menu item is a vector of three or four elements:

 - the name of the menu item (a string);
 - the `callback' of that item;
 - whether this item is active (selectable);
 - and an optional string to append to the name.

If the `callback' of a menu item is a symbol, then it must name a command.
It will be invoked with `call-interactively'.  If it is a list, then it is
evaluated with `eval'.

The fourth element of a menu item is a convenient way of adding the name
of a command's ``argument'' to the menu, like ``Kill Buffer NAME''.

If an element of a menu (or menubar) is a string, then that string will be
presented in the menu (or menubar) as unselectable text.

If an element of a menu is a string consisting solely of hyphens, then that
item will be presented as a solid horizontal line.

If an element of a menu is a list, it is treated as a submenu.  The name of
that submenu (the first element in the list) will be used as the name of
the item representing this menu on the parent.

If an element of a menubar is `nil', then it is used to represent the
division between the set of menubar-items which are flushleft and those
which are flushright.  (Note: this isn't completely implemented yet.)

After the menubar is clicked upon, but before any menus are popped up,
the functions on the `activate-menubar-hook' are invoked to make changes
to the menus and menubar.  This is intended to implement lazy alteration
of the sensitivity of menu items.

The syntax, more precisely:

   form        :=  <something to pass to `eval'>
   command    :=  <a symbol or string, to pass to `call-interactively'>
   callback     :=  command | form
   active-p    :=  <t or nil, whether this thing is selectable>
   text        :=  <string, non selectable>
   name        :=  <string>
   argument    :=  <string>
   menu-item    :=  '['  name callback active-p [ argument ]  ']'
   menu        :=  '(' name [ menu-item | menu | text ]+ ')'
   partition    :=  'nil'
   menubar    :=  '(' [ menu-item | menu | text ]* [ partition ]
                [ menu-item | menu | text ]*
             ')'Vactivate-menubar-hook
Function or functions called before a menubar menu is pulled down.
These functions are called with no arguments, and should interrogate and
modify the value of `current-menubar' as desired.

The functions on this hook are invoked after the mouse goes down, but before
the menu is mapped, and may be used to activate, deactivate, add, or delete
items from the menus.

These functions may return the symbol `t' to assert that they have made
no changes to the menubar.  If any other value is returned, the menubar is
recomputed.  If `t' is returned but the menubar has been changed, then the
changes may not show up right away.  Returning `nil' when the menubar has
not changed is not so bad; more computation will be done, but redisplay of
the menubar will still be performed optimally.Vmenu-no-selection-hook
Function or functions to call when a menu or dialog box is dismissed
without a selecting having been made.Vmenubar-show-keybindings
If true, the menubar will display keyboard equivalents.
If false, only the command names will be displayed.Fminibuffer-depth
Return current depth of activations of minibuffer, a nonnegative integer.

arguments:()
Fread-minibuffer-internal
Lowest-level interface to minibuffers.  Don't call this.

arguments:(prompt)
Ftry-completion
Return common substring of all completions of STRING in ALIST.
Each car of each element of ALIST is tested to see if it begins with STRING.
All that match are compared together; the longest initial sequence
common to all matches is returned as a string.
If there is no match at all, nil is returned.
For an exact match, t is returned.

ALIST can be an obarray instead of an alist.
Then the print names of all symbols in the obarray are the possible matches.

ALIST can also be a function to do the completion itself.
It receives three arguments: the values STRING, PREDICATE and nil.
Whatever it returns becomes the value of `try-completion'.

If optional third argument PREDICATE is non-nil,
it is used to test each possible match.
The match is a candidate only if PREDICATE returns non-nil.
The argument given to PREDICATE is the alist element or the symbol from the obarray.

arguments:(string alist &optional pred)
Fall-completions
Search for partial matches to STRING in ALIST.
Each car of each element of ALIST is tested to see if it begins with STRING.
The value is a list of all the strings from ALIST that match.
ALIST can be an obarray instead of an alist.
Then the print names of all symbols in the obarray are the possible matches.

ALIST can also be a function to do the completion itself.
It receives three arguments: the values STRING, PREDICATE and t.
Whatever it returns becomes the value of `all-completions'.

If optional third argument PREDICATE is non-nil,
it is used to test each possible match.
The match is a candidate only if PREDICATE returns non-nil.
The argument given to PREDICATE is the alist element or
the symbol from the obarray.

arguments:(string alist &optional pred)
Vcompletion-ignore-case
Non-nil means don't consider case significant in completion.Fml-if
Mocklisp version of `if'.

arguments: (&rest args)
Fml-nargs
Number of arguments to currently executing mocklisp function.

arguments:()
Fml-arg
Argument number N to currently executing mocklisp function.

arguments:(n &optional prompt)
Fml-interactive
True if currently executing mocklisp function was called interactively.

arguments:()
Fml-provide-prefix-argument
Evaluate second argument, using first argument as prefix arg value.

arguments: (arg1 arg2 &rest args)
Fml-prefix-argument-loop


arguments: (&rest args)
Fml-substr
Return a substring of STRING, starting at index FROM and of length LENGTH.
If either FROM or LENGTH is negative, the length of STRING is added to it.

arguments:(string from to)
Finsert-string
Mocklisp-compatibility insert function.
Like the function `insert' except that any argument that is a number
is converted into a string by expressing it in decimal.

arguments: (&rest args)
Fwin-exec
Run Windows program PROGRAM and don't wait for it to finish.
Second argument SHOW-STATE specifies how the program's window
will be shown, and should be one of the following symbols:

 'win-show-hide
    Hide the window, don't change focus.

 'win-show-min
 'win-show-min-focus
 'win-show-min-focus-next
    Minimize the window; don't change the focus, focus on the
    window, and focus on the next top-level window, respectively.

 'win-show-max-focus
    Maximize the window and focus on it.

 'win-show-normal
 'win-show-normal-focus
    Show the window in its normal state (not maximized or
    minimized); don't change the focus or focus on the
    window, respectively.

 'win-show-current
 'win-show-current-focus
    If the window was hidden, set it to its previously shown
    state; otherwise don't change the state.  Don't change the
    focus or focus on the window, respectively.

Some of the above values only make sense if an instance of the
program is already running.  Note that the display-state specified
here is only a suggestion to the program, which is free to ignore
or reinterpret it.

Remaining args are the parameters passed to the function.

Upon success, returns value from WinExec(). [This may change in the future.]

arguments: (arg1 arg2 &rest args)
Fwin-breakpoint
Under Windows, issue an INT 3 to return to the debugger.

arguments:()
Fx-focus-window
Set the focus to a specified X window.
WINDOW should be a string containing the numeric ID of the window.
If NIL, set the focus to the top-level window of the selected screen.

arguments:(window)
Fwin-poke-linear-memory
Write a string into raw linear memory.
LENGTH bytes of STRING (defaults to the size of the string) are written
starting at linear address ADDRESS, which should be a cons (HI . LOW).
The actual address is constructed by the formula (HI << 16) + LOW.
HI must be in the range 0 to 65535 inclusive, but LOW can be any
integer.

Beware!  Use of this function can violate the integrity of the system
and cause it to crash, so make sure you know what you are doing.
Currently, no check is made to verify that the address you are
accessing actually exists, and a GP fault can occur if it doesn't.

arguments:(address string &optional length)
Fwin-peek-linear-memory
Read a string from raw linear memory.
LENGTH bytes are read starting at linear address ADDRESS, which should be
a cons (HI . LOW).  The actual address is constructed by the formula
(HI << 16) + LOW.  HI must be in the range 0 to 65535 inclusive, but LOW
can be any integer.  If STRING is a string, the bytes read will be written
into it; in this case, LENGTH can be omitted and defaults to the length
of the string.  Otherwise, a new string will be created.  In both cases,
the string written into is returned.

Beware!  Use of this function can violate the integrity of the system
and cause it to crash, so make sure you know what you are doing.
Currently, no check is made to verify that the address you are
accessing actually exists, and a GP fault can occur if it doesn't.

arguments:(address string &optional length)
Fcommdlg-get-open-file-name
Interface to the MS Windows Common Dialog get-open-file-name dialog box.
Optional argument INITIAL specifies the default value for the filename.
If not given, the filename will initially be blank.  Optional second
argument TITLE specifies the title of the dialog box.  If not given, the
title will be "Open".  Optional third argument INITIAL_FILTER specifies
the initial

arguments:(&optional initial title initial_filter filter_list)
Fcommdlg-choose-font
Interface to the MS Windows Common Dialog choose-font dialog box.
Optional argument INITIAL is a string specifying the initial font
selected in the dialog box.  Optional second argument VARIABLE-P,
if not nil, specifies that variable-width fonts can be selected; if
nil or not specified, the dialog box will only display fixed-pitch
fonts.  Optional third and fourth arguments MINSIZE and MAXSIZE
specify the minimum and maximum point sizes that can be selected.
If MINSIZE is given, then MAXSIZE must also be given.  Return value
is a string giving the font name that was selected.

arguments:(&optional initial variable_p minsize maxsize)
Fcommdlg-choose-color
Interface to the MS Windows Common Dialog choose-color dialog box.


arguments:(&optional initial)
Fwin-print-setup
Display the standard Print Setup dialog box.
Lisp code calls this function when the user chooses Print Setup...
from the File menu.

arguments:()
Fwin-print-region
Print the contents of a buffer region.
Args START and END specify the region to print.
Arg BUFFER is the buffer.
Fourth arg SCREEN is the screen which is used for mapping faces to fonts.
Fifth arg JOBNAME is the print job name which will appear in Print Manager
  (max 31 characters).

BUFFER, SCREEN, and JOBNAME are optional, and default to the current buffer,
the selected screen, and a name constructed from the buffer name,
respectively.

If there is a selected region, the Selection choice in the dialog box
will be enabled and chosen by default; otherwise, it will be disabled.
When Selection is the default and the user chooses All, the entire
visible portion of the buffer will be printed.

Returns t if the document was successfully printed, nil otherwise
(i.e. the user canceled the operation).

arguments:(l_start l_end &optional l_buffer l_screen l_jobName)
Fhandlep
T if OBJECT is a handle.

arguments:(obj)
Fdde-dispatch-internal
Dispatch a DDE event.  Do not call this function.

arguments:(data)
Fdde-connect
Initiate a DDE conversation.
First argument (string) is the service name (sometimes called the
   application name).
Second argument (string) is the topic name.
Returns a handle which can be used for further transactions.

arguments:(l_service l_topic)
Fdde-disconnect
Close a DDE connection.
Any incomplete transactions that were started asynchronously
with dde-request or dde-execute are immediately abandoned.

arguments:(handle)
Fdde-execute
Ask a DDE server to execute a command.
First argument is a conversation handle returned by dde-initiate.
Second argument is the command string.
Third argument is the maximum time to wait for a server response, measured
in milliseconds.  If 0, the command executes asynchronously, and the
function call returns a transaction handle.  The function `dde-acknowledge'
will be called when the command has finished executing.

arguments:(l_handle l_command l_timeout)
Fdde-request
Retrieve string data from a DDE server.
First argument is a conversation handle returned by dde-initiate.
Second argument is a string containing the item name.
Third argument is the maximum time to wait for a server response, measured
in milliseconds.  If 0, the response will arrive asynchronously, and the
function call returns a transaction handle.  The function `dde-acknowledge'
will be called when the response arrives.

arguments:(l_conv l_item l_timeout)
Vwin-dos-process-show-state
The state that the window corresponding to a DOS process will be shown in.
This applies to processes invoked using `call-process'.  This should be a
symbol; see `win-exec' for a list of the valid symbols and what they mean.Vcommdlg-initial-file-filter
The default initial file filter in commdlg-get-open-file-name dialog boxes.
This should be a cons of two strings, the first describing the nature of
the file selected by the filter (for example, "Text Files"), and the
second specifying the filter itself, as one or more standard MS-DOS wildcard
specifications separated by semicolons (for example, "*.txt;*.doc").Vcommdlg-file-filter-list
The default file filter list in commdlg-get-open-file-name dialog boxes.
This should be a list of conses of (FILTER-DESCRIPTION . FILTER); see
`commdlg-initial-file-filter' for more information.Vprint-margin-units
Holds either the symbol 'cm or 'inch, representing the units in which
the variables print-margin-left, print-margin-right, print-margin-top, and
print-margin-bottom are to be interpreted.Vprint-margin-left
A floating-point number representing the left margin size
for Win-Emacs printing.Vprint-margin-right
A floating-point number representing the right margin size
for Win-Emacs printing.Vprint-margin-top
A floating-point number representing the top margin size
for Win-Emacs printing.Vprint-margin-bottom
A floating-point number representing the bottom margin size
for Win-Emacs printing.Vprint-wrap
If t, printed lines will wrap; if nil, they will be truncated
at the right margin.Vdde-topics
List of strings representing DDE topics on which Emacs will accept connections
as a DDE server.  If t, Emacs will accept connections on any topic.Vdde-acknowledge
Contains a function which is called when DDE data requested
asynchronously arrives or when an acknowledgement of DDE asynchronous
command execution is received.  If nil, the acknowledgement is ignored.Vdde-server-execute
Contains a function which is called when a client requests that Emacs execute
a command as a DDE server.  First argument is the conversation handle;
second argument is the topic name (a string); third argument is the string
to execute.  The function returns true if the command is executed,
nil if the server rejects it.  If dde-server-execute is nil, all requests
are denied.Vdde-server-request
Contains a function which is called when a client requests data
from Emacs as a DDE server.  The function returns a string which is
returned to the DDE client.  If nil, all requests are denied.Fprocessp
Return t if OBJECT is a process.

arguments:(obj)
Fget-process
Return the process named NAME, or nil if there is none.

arguments:(name)
Fget-buffer-process
Return the (or, a) process associated with BUFFER.
BUFFER may be a buffer or the name of one.

arguments:(name)
Fdelete-process
Delete PROCESS: kill it and forget about it immediately.
PROCESS may be a process or the name of one, or a buffer name.

arguments:(proc)
Fprocess-status
Return the status of PROCESS: a symbol, one of these:
run  -- for a process that is running.
stop -- for a process stopped but continuable.
exit -- for a process that has exited.
signal -- for a process that has got a fatal signal.
open -- for a network stream connection that is open.
closed -- for a network stream connection that is closed.
nil -- if arg is a process name and no such process exists.

arguments:(proc)
Fprocess-exit-status
Return the exit status of PROCESS or the signal number that killed it.
If PROCESS has not yet exited or died, return 0.
If PROCESS is a net connection that was closed remotely, return 256.

arguments:(proc)
Fprocess-id
Return the process id of PROCESS.
This is the pid of the Unix process which PROCESS uses or talks to.
For a network connection, this value is nil.

arguments:(proc)
Fprocess-name
Return the name of PROCESS, as a string.
This is the name of the program invoked in PROCESS,
possibly modified to make it unique among process names.

arguments:(proc)
Fprocess-command
Return the command that was executed to start PROCESS.
This is a list of strings, the first string being the program executed
and the rest of the strings being the arguments given to it.
For a non-child channel, this is nil.

arguments:(proc)
Fset-process-buffer
Set buffer associated with PROCESS to BUFFER (a buffer, or nil).

arguments:(proc buffer)
Fprocess-buffer
Return the buffer PROCESS is associated with.
Output from PROCESS is inserted in this buffer
unless PROCESS has a filter.

arguments:(proc)
Fprocess-mark
Return the marker for the end of the last output from PROCESS.

arguments:(proc)
Fset-process-filter
Give PROCESS the filter function FILTER; nil means no filter.
When a process has a filter, each time it does output
the entire string of output is passed to the filter.
The filter gets two arguments: the process and the string of output.
If the process has a filter, its buffer is not used for output.

arguments:(proc filter)
Fprocess-filter
Returns the filter function of PROCESS; nil if none.
See `set-process-filter' for more info on filter functions.

arguments:(proc)
Fset-process-sentinel
Give PROCESS the sentinel SENTINEL; nil for none.
The sentinel is called as a function when the process changes state.
It gets two arguments: the process, and a string describing the change.

arguments:(proc sentinel)
Fprocess-sentinel
Return the sentinel of PROCESS; nil if none.
See `set-process-sentinel' for more info on sentinels.

arguments:(proc)
Fprocess-kill-without-query
Say no query needed if PROCESS is running when Emacs is exited.
Optional second argument if non-nil says to require a query.
Value is t if a query was formerly required.

arguments:(proc &optional value)
Fprocess-kill-without-query-p
Return t or nil, depending on whether or not PROCESS will be killed
without query.

arguments:(proc)
Flist-processes
Display a list of all processes.
(Any processes listed as Exited or Signaled are actually eliminated
after the listing is made.)

arguments:()
Fprocess-list
Return a list of all processes.

arguments:()
Fstart-process
Start a program in a subprocess.  Return the process object for it.
Args are NAME BUFFER PROGRAM &rest PROGRAM-ARGS
NAME is name for process.  It is modified if necessary to make it unique.
BUFFER is the buffer or (buffer-name) to associate with the process.
 Process output goes at end of that buffer, unless you specify
 an output stream or filter function to handle the output.
 BUFFER may be also nil, meaning that this process is not associated
 with any buffer
Third arg is program file name.  It is searched for as in the shell.
Remaining arguments are strings to give program as arguments.

arguments: (arg1 arg2 arg3 &rest args)
Fstart-process
Not currently implemented.

arguments: (arg1 arg2 arg3 &rest args)
Fopen-network-stream
Open a TCP connection for a service to a host.
Returns a subprocess-object to represent the connection.
Input and output work as for subprocesses; `delete-process' closes it.
Args are NAME BUFFER HOST SERVICE.
NAME is name for process.  It is modified if necessary to make it unique.
BUFFER is the buffer (or buffer-name) to associate with the process.
 Process output goes at end of that buffer, unless you specify
 an output stream or filter function to handle the output.
 BUFFER may be also nil, meaning that this process is not associated
 with any buffer
Third arg is name of the host to connect to.
Fourth arg SERVICE is name of the service desired, or an integer
 specifying a port number to connect to.

arguments:(name buffer host service)
Fwaiting-for-user-input-p
Returns non-NIL if emacs is waiting for input from the user.
This is intended for use by asynchronous process output filters and sentinels.

arguments:()
Fprocess-send-region
Send current contents of region as input to PROCESS.
PROCESS may be a process name or an actual process.
Called from program, takes three arguments, PROCESS, START and END.
If the region is more than 500 characters long,
it is sent in several bunches.  This may happen even for shorter regions.
Output from processes can arrive in between bunches.

arguments:(process start end)
Fprocess-send-string
Send PROCESS the contents of STRING as input.
PROCESS may be a process name or an actual process.
If STRING is more than 500 characters long,
it is sent in several bunches.  This may happen even for shorter strings.
Output from processes can arrive in between bunches.

arguments:(process string)
Finterrupt-process
Interrupt process PROCESS.  May be process or name of one.
Nil or no arg means current buffer's process.
Second arg CURRENT-GROUP non-nil means send signal to
the current process-group of the process's controlling terminal
rather than to the process's own process group.
If the process is a shell, this means interrupt current subjob
rather than the shell.

arguments:(&optional process current_group)
Fkill-process
Kill process PROCESS.  May be process or name of one.
See function `interrupt-process' for more details on usage.

arguments:(&optional process current_group)
Fquit-process
Send QUIT signal to process PROCESS.  May be process or name of one.
See function `interrupt-process' for more details on usage.

arguments:(&optional process current_group)
Fstop-process
Stop process PROCESS.  May be process or name of one.
See function `interrupt-process' for more details on usage.

arguments:(&optional process current_group)
Fcontinue-process
Continue process PROCESS.  May be process or name of one.
See function `interrupt-process' for more details on usage.

arguments:(&optional process current_group)
Fsignal-process
Send the process with number PID the signal with code CODE.
Both PID and CODE are integers.

arguments:(pid sig)
Finterrupt-process
Not currently implemented.

arguments:(&optional process current_group)
Fkill-process
Not currently implemented.

arguments:(&optional process current_group)
Fquit-process
Not currently implemented.

arguments:(&optional process current_group)
Fstop-process
Not currently implemented.

arguments:(&optional process current_group)
Fcontinue-process
Not currently implemented.

arguments:(&optional process current_group)
Fsignal-process
Not currently implemented.

arguments:(pid sig)
Fprocess-send-eof
Make PROCESS see end-of-file in its input.
Eof comes after any text already sent to it.
nil or no arg means current buffer's process.

arguments:(&optional process)
Fprocess-send-eof
Not currently implemented.

arguments:(&optional process)
Fprocess-connection
Return the connection type of `PROCESS'.  This can be nil (pipe),
t or pty (pty) or stream (socket connection).

arguments:(&optional process)
Fhas-subprocesses-p
Whether subprocess support exists.

arguments:()
Vdelete-exited-processes
*Non-nil means delete processes immediately when they exit.
nil means don't delete them until `list-processes' is run.Vprocess-connection-type
Control type of device used to communicate with subprocesses.
Values are nil to use a pipe, and t or 'pty for a pty.  Note that if
pty's are not available, this variable will be ignored. The value takes
effect when `start-process' is called.Fwrite-char
Output character CHAR to stream STREAM.
STREAM defaults to the value of `standard-output' (which see).

arguments:(ch &optional printcharfun)
Fwith-output-to-temp-buffer
Bind `standard-output' to buffer BUFNAME, eval BODY, then show that buffer.
The buffer is cleared out initially, and marked as unmodified when done.
All output done by BODY is inserted in that buffer by default.
The buffer is displayed in another window, but not selected.
The value of the last form in BODY is returned.
If BODY does not finish normally, the buffer BUFNAME is not displayed.

If variable `temp-buffer-show-function' is non-nil, call it at the end
to get the buffer displayed.  It gets one argument, the buffer to display.

arguments: (arg1 &rest args)
Fterpri
Output a newline to STREAM.
If STREAM is omitted or nil, the value of `standard-output' is used.

arguments:(&optional printcharfun)
Fprin1
Output the printed representation of OBJECT, any Lisp object.
Quoting characters are printed when needed to make output that `read'
can handle, whenever this is possible.
Output stream is STREAM, or value of `standard-output' (which see).

arguments:(obj &optional printcharfun)
Fprin1-to-string
Return a string containing the printed representation of OBJECT,
any Lisp object.  Quoting characters are used when needed to make output
that `read' can handle, whenever this is possible, unless the optional
second argument NOESCAPE is non-nil.

arguments:(obj &optional noescape)
Fprinc
Output the printed representation of OBJECT, any Lisp object.
No quoting characters are used; no delimiters are printed around
the contents of strings.
Output stream is STREAM, or value of standard-output (which see).

arguments:(obj &optional printcharfun)
Fprint
Output the printed representation of OBJECT, with newlines around it.
Quoting characters are printed when needed to make output that `read'
can handle, whenever this is possible.
Output stream is STREAM, or value of `standard-output' (which see).

arguments:(obj &optional printcharfun)
Falternate-debugging-output
Append CHARACTER to a string.
You can call print while debugging emacs, and pass it this function
to make it write to the debugging output.


arguments:(character)
Fexternal-debugging-output
Write CHARACTER to stderr.
You can call print while debugging emacs, and pass it this function
to make it write to the debugging output.


arguments:(character)
Vstandard-output
Output stream `print' uses by default for outputting a character.
This may be any function of one argument.
It may also be a buffer (output is inserted before point)
or a marker (output is inserted and the marker is advanced)
or the symbol t (output appears in the minibuffer line).Vfloat-output-format
The format descriptor string that lisp uses to print floats.
This is a %-spec like those accepted by `printf' in C,
but with some restrictions.  It must start with the two characters `%.'.
After that comes an integer precision specification,
and then a letter which controls the format.
The letters allowed are `e', `f' and `g'.
Use `e' for exponential notation "DIG.DIGITSeEXPT"
Use `f' for decimal point notation "DIGITS.DIGITS".
Use `g' to choose the shorter of those two formats for the number at hand.
The precision in any of these cases is the number of digits following
the decimal point.  With `f', a precision of 0 means to omit the
decimal point.  0 is not allowed with `f' or `g'.

A value of nil means to use `%.16g'.

Regardless of the value of `float-output-format', a floating point number
will never be printed in such a way that it is ambiguous with an integer;
that is, a floating-point number will always be printed with a decimal
point and/or an exponent, even if the digits following the decimal point
are all zero.  This is to preserve read-equivalence.Vprint-length
Maximum length of list to print before abbreviating.A value of nil means no limit.Vprint-level
Maximum depth of list nesting to print before abbreviating.A value of nil means no limit.Vprint-escape-newlines
Non-nil means print newlines in strings as backslash-n.Vprint-readably
If non-nil, then all objects will be printed in a readable form.
If an object has no readable representation, then an error is signalled.
When this is true, compiled-function objects will be written in #[...] form
instead of in #<byte-code [...]> form.
Do not SET this variable; bind it instead.Vprint-gensym
If non-nil, then uninterned symbols (those made with `make-symbol'
instead of `intern') will be preceeded by "#:", which tells the reader to
create a new symbol instead of interning.  Beware: the #: syntax creates a
new symbol each time it is seen, so if you print an object which contains
two pointers to the same uninterned symbol, `read' will not duplicate that
structure.Fscreenp
Return non-nil if OBJECT is a screen.
Value is t for a termcap screen (a character-only terminal),
`x' for an Emacs screen that is really an X window.

arguments:(screen)
Fselect-screen
Select the screen S.
S's selected window becomes the selected window.

arguments:(screen)
Fselected-screen
Return the screen that is now selected.

arguments:()
Fwindow-screen
Return the screen that window WINDOW is on.

arguments:(window)
Fscreen-root-window
Returns the root-window of SCREEN.

arguments:(&optional screen)
Fscreen-selected-window
Return the selected window of screen SCREEN.

arguments:(&optional screen)
Fscreen-list
Return a list of all screens.

arguments:()
Fnext-screen
Return the next screen in the screen list after SCREEN.
If MINISCREEN is non-nil, include the global-minibuffer-screen if it
has its own screen.
If VISIBLE-ONLY-P is non-nil, then cycle through the visible screens,
instead of all screens.

arguments:(&optional screen miniscreen visible_only_p)
Fprevious-screen
Return the previous screen in the screen list after SCREEN.
If MINISCREEN is non-nil, include the global-minibuffer-screen if it
has its own screen.
If VISIBLE-ONLY-P is non-nil, then cycle through the visible screens,
instead of all screens.

arguments:(&optional screen miniscreen visible_only_p)
Fdelete-screen
Delete SCREEN, permanently eliminating it from use.
Default is current screen.

arguments:(&optional screen)
Fread-mouse-position
Return a cons (x . y) which represents the position of the mouse.

arguments:(screen)
Fset-mouse-position
Move the mouse pointer to the center of character cell (X,Y) in SCREEN.

arguments:(screen x y)
Fscreen-configuration
Return object describing current screen configuration.
The screen configuration is the current mouse position and selected screen.
This object can be given to `restore-screen-configuration'
to restore this screen configuration.

arguments:()
Frestore-screen-configuration
Restores screen configuration CONFIGURATION.

arguments:(config)
Fmake-screen-visible
Make the screen SCREEN visible (assuming it is an X-window).
Also raises the screen so that nothing obscures it.

arguments:(screen)
Fmake-screen-invisible
Unconditionally removes screen from the display (assuming it is an X-window).
If what you want to do is iconify the screen (if the window manager uses
icons) then you should call `iconify-screen' instead.

arguments:(screen)
Ficonify-screen
Make the screen SCREEN into an icon, if the window manager supports icons.

arguments:(screen)
Fdeiconify-screen
Open (de-iconify) the iconified screen SCREEN.

arguments:(screen)
Fscreen-visible-p
Return t if SCREEN is now "visible" (actually in use for display).
A screen that is not "visible" is not updated and, if it works through
a window system, it may not show at all.
Return the symbol `icon' if window is visible only as an icon.

arguments:(screen)
Fvisible-screen-list
Return a list of all screens now "visible" (being updated).

arguments:()
Fscreen-parameters
Return the parameters-alist of screen SCREEN.
It is a list of elements of the form (PARM . VALUE), where PARM is a symbol.
The meaningful PARMs depend on the kind of screen.

arguments:(&optional screen)
Fmodify-screen-parameters
Modify the parameters of screen SCREEN according to ALIST.
ALIST is an alist of parameters to change and their new values.
Each element of ALIST has the form (PARM . VALUE), where PARM is a symbol.
The meaningful PARMs depend on the kind of screen; undefined PARMs are ignored.

arguments:(screen alist)
Fscreen-height
Return number of lines available for display on SCREEN.

arguments:(&optional screen)
Fscreen-width
Return number of columns available for display on SCREEN.

arguments:(&optional screen)
Fscreen-name
Returns the name of SCREEN (defaulting to the selected screen).
This is not the same as the `title' of the screen.

arguments:(&optional screen)
Fscreen-totally-visible-p
Return T if screen is not obscured by any other X windows, NIL otherwise

arguments:(&optional screen)
Fset-screen-height
Specify that the screen SCREEN has LINES lines.
Optional third arg non-nil means that redisplay should use LINES lines
but that the idea of the actual height of the screen should not be changed.

arguments:(screen rows &optional pretend)
Fset-screen-width
Specify that the screen SCREEN has COLS columns.
Optional third arg non-nil means that redisplay should use COLS columns
but that the idea of the actual width of the screen should not be changed.

arguments:(screen cols &optional pretend)
Fset-screen-size
Sets size of SCREEN to COLS by ROWS.
Optional fourth arg non-nil means that redisplay should use COLS by ROWS
but that the idea of the actual size of the screen should not be changed.

arguments:(screen cols rows &optional pretend)
Fset-screen-position
Sets position of SCREEN in pixels to XOFFSET by YOFFSET.

arguments:(screen xoffset yoffset)
Fraise-screen
Make the window of SCREEN be the uppermost one (fully visible).

arguments:(screen)
Flower-screen
Make the window of SCREEN be the bottommost one.

arguments:(screen)
Fcoordinates-in-window-p
Return non-nil if COORDINATES are in WINDOW.
COORDINATES is a cons of the form (X Y), X and Y being screen-relative.
If COORDINATES are in the text portion of WINDOW, the coordinates relative
to the window are returned.  If they are in the modeline of WINDOW, t is
returned.

arguments:(coordinates window)
Flocate-window-from-coordinates
Return window on SCREEN containing position COORDINATES.
COORDINATES is a list (SCREEN-X SCREEN-Y) of coordinates
which are relative to 0,0 at the top left corner of the screen.

arguments:(screen coordinates)
Vterminal-screen
The initial screen-object, which represents Emacs's stdout.Vglobal-minibuffer-screen
A screen-object holding the default minibuffer for minibufferless screens.
When you create a minibufferless screen, by default it will use the
minibuffer of this screen.  It is up to you to create a suitable screen
and store it in this variable.Vallow-deletion-of-last-visible-screen
*If nil, the last visible screen may not be deleted by `delete-window'
You can never delete the last screen, but setting this to t will allow you
to delete the last non-iconified screen.Vcreate-screen-hook
Function or functions of one argument, called with each newly-created screen.Vmouse-enter-screen-hook
Function or functions to call when mouse enters a screen.  One arg, the screen.
Be careful not to make assumptions about the window manger's focus model.
In most cases, the `deselect-screen-hook' is more appropriate.Vmouse-leave-screen-hook
Function or functions to call when mouse leaves screen.  One arg, the screen.
Be careful not to make assumptions about the window manger's focus model.
In most cases, the `select-screen-hook' is more appropriate.Vmap-screen-hook
Function or functions to call when screen is mapped.
One arg, the screen.Vunmap-screen-hook
Function or functions to call when screen is unmapped.
One arg, the screen.Vmouse-motion-handler
Handler for motion events.  One arg, the event.
For most applications, you should use `mode-motion-hook' instead of this.Vmouse-grabbed-buffer
A buffer which should be consulted first for all mouse activity.
When a mouse-clicked it processed, it will first be looked up in the
local-map of this buffer, and then through the normal mechanism if there
is no binding for that click.  This buffer's value of `mode-motion-hook'
will be consulted instead of the `mode-motion-hook' of the buffer of the
window under the mouse.  You should *bind* this, not set it.Flooking-at
t if text after point matches regular expression PAT.

arguments:(string)
Fstring-match
Return index of start of first match for REGEXP in STRING, or nil.
If third arg START is non-nil, start search at that index in STRING.
For index of first char beyond the match, do (match-end 0).
match-end and match-beginning also give indices of substrings
matched by parenthesis constructs in the pattern.

arguments:(regexp string &optional start)
Fskip-chars-forward
Move point forward, stopping before a char not in CHARS, or at position LIM.
CHARS is like the inside of a [...] in a regular expression
except that ] is never special and \ quotes ^, - or \.
Thus, with arg "a-zA-Z", this skips letters stopping before first nonletter.
With arg "^a-zA-Z", skips nonletters stopping before first letter.

arguments:(string &optional lim)
Fskip-chars-backward
Move point backward, stopping after a char not in CHARS, or at position LIM.
See skip-chars-forward for details.

arguments:(string &optional lim)
Fsearch-backward
Search backward from point for STRING.
Set point to the beginning of the occurrence found, and return t.
An optional second argument bounds the search; it is a buffer position.
The match found must not extend before that position.
Optional third argument, if t, means if fail just return nil (no error).
 If not nil and not t, position at limit of search and return nil.
Optional fourth argument is repeat count--search for successive occurrences.

arguments:(string &optional bound noerror count)
Fsearch-forward
Search forward from point for STRING.
Set point to the end of the occurrence found, and return t.
An optional second argument bounds the search; it is a buffer position.
The match found must not extend after that position.
Optional third argument, if t, means if fail just return nil (no error).
  If not nil and not t, move to limit of search and return nil.
Optional fourth argument is repeat count--search for successive occurrences.

arguments:(string &optional bound noerror count)
Fword-search-backward
Search backward from point for STRING, ignoring differences in punctuation.
Set point to the beginning of the occurrence found, and return t.
An optional second argument bounds the search; it is a buffer position.
The match found must not extend before that position.
Optional third argument, if t, means if fail just return nil (no error).
  If not nil and not t, move to limit of search and return nil.
Optional fourth argument is repeat count--search for successive occurrences.

arguments:(string &optional bound noerror count)
Fword-search-forward
Search forward from point for STRING, ignoring differences in punctuation.
Set point to the end of the occurrence found, and return t.
An optional second argument bounds the search; it is a buffer position.
The match found must not extend after that position.
Optional third argument, if t, means if fail just return nil (no error).
  If not nil and not t, move to limit of search and return nil.
Optional fourth argument is repeat count--search for successive occurrences.

arguments:(string &optional bound noerror count)
Fre-search-backward
Search backward from point for match for regular expression REGEXP.
Set point to the beginning of the match, and return t.
The match found is the one starting last in the buffer
and yet ending before the place the origin of the search.
An optional second argument bounds the search; it is a buffer position.
The match found must start at or after that position.
Optional third argument, if t, means if fail just return nil (no error).
  If not nil and not t, move to limit of search and return nil.
Optional fourth argument is repeat count--search for successive occurrences.
See also the functions match-beginning and match-end and replace-match.

arguments:(string &optional bound noerror count)
Fre-search-forward
Search forward from point for regular expression REGEXP.
Set point to the end of the occurrence found, and return t.
An optional second argument bounds the search; it is a buffer position.
The match found must not extend after that position.
Optional third argument, if t, means if fail just return nil (no error).
  If not nil and not t, move to limit of search and return nil.
Optional fourth argument is repeat count--search for successive occurrences.
See also the functions match-beginning and match-end and replace-match.

arguments:(string &optional bound noerror count)
Freplace-match
Replace text matched by last search with NEWTEXT.
If second arg FIXEDCASE is non-nil, do not alter case of replacement text.
Otherwise convert to all caps or cap initials, like replaced text.
If third arg LITERAL is non-nil, insert NEWTEXT literally.
Otherwise treat \ as special:
  \& in NEWTEXT means substitute original matched text,
  \N means substitute match for \(...\) number N,
  \\ means insert one \.
Leaves point at end of replacement text.

arguments:(string &optional fixedcase literal)
Fmatch-beginning
Return the character number of start of text matched by last regexp searched for.
ARG, a number, specifies which parenthesized expression in the last regexp.
 Value is nil if ARGth pair didn't match, or there were less than ARG pairs.
Zero means the entire text matched by the whole regexp.

arguments:(num)
Fmatch-end
Return the character number of end of text matched by last regexp searched for.
ARG, a number, specifies which parenthesized expression in the last regexp.
 Value is nil if ARGth pair didn't match, or there were less than ARG pairs.
Zero means the entire text matched by the whole regexp.

arguments:(num)
Fmatch-data
Return list containing all info on what the last search matched.
Element 2N is (match-beginning N); element 2N + 1 is (match-end N).
All the elements are normally markers, or nil if the Nth pair didn't match.
0 is also possible, when matching was done with `string-match',
if a match began at index 0 in the string.

arguments:()
Fstore-match-data
Set internal data on last search match from elements of LIST.
LIST should have been created by calling match-data previously.

arguments:(list)
Fregexp-quote
Return a regexp string which matches exactly STRING and nothing else.

arguments:(str)
Fsyntax-table-p
Return t if ARG is a syntax table.
Any vector of 256 elements will do.

arguments:(obj)
Fsyntax-table
Return the current syntax table.
This is the one specified by the current buffer.

arguments:()
Fstandard-syntax-table
Return the standard syntax table.
This is the one used for new buffers.

arguments:()
Fcopy-syntax-table
Construct a new syntax table and return it.
It is a copy of the TABLE, which defaults to the standard syntax table.

arguments:(&optional table)
Fset-syntax-table
Select a new syntax table for the current buffer.
One argument, a syntax table.

arguments:(table)
Fchar-syntax
Return the syntax code of CHAR, described by a character.
For example, if CHAR is a word constituent, the character `?w' is returned.
The characters that correspond to various syntax codes
are listed in the documentation of `modify-syntax-entry'.

arguments:(ch)
Fmodify-syntax-entry
Set syntax for character CHAR according to string S.
The syntax is changed only for table TABLE, which defaults to
 the current buffer's syntax table.
The first character of S should be one of the following:
  Space    whitespace syntax.    w   word constituent.
  _        symbol constituent.   .   punctuation.
  (        open-parenthesis.     )   close-parenthesis.
  "        string quote.         \   character-quote.
  $        paired delimiter.     '   expression quote or prefix operator.
  <       comment starter.     >   comment ender.
Only single-character comment start and end sequences are represented thus.
Two-character sequences are represented as described below.
The second character of S is the matching parenthesis,
 used only if the first character is `(' or `)'.
Any additional characters are flags.
Defined flags are the characters 1, 2, 3, 4, 5, 6, 7, 8, p, a, and b.
 1 means C is the first of a two-char comment start sequence of style a.
 2 means C is the second character of such a sequence.
 3 means C is the first of a two-char comment end sequence of style a.
 4 means C is the second character of such a sequence.
 5 means C is the first of a two-char comment start sequence of style b.
 6 means C is the second character of such a sequence.
 7 means C is the first of a two-char comment end sequence of style b.
 8 means C is the second character of such a sequence.
 p means C is a prefix character for `backward-prefix-chars';
   such characters are treated as whitespace when they occur
   between expressions.
 a means C is comment starter or comment ender for comment style a (default)
 b means C is comment starter or comment ender for comment style b.

arguments:(c newentry syntax_table)
Fdescribe-syntax
Describe the syntax specifications in the syntax table.
The descriptions are inserted in a buffer, which is then displayed.

arguments:()
Fforward-word
Move point forward ARG words (backward if ARG is negative).
Normally returns t.
If an edge of the buffer is reached, point is left there
and nil is returned.

arguments:(count)
Fbackward-syntactic-ws
Move point backward over all syntactic whitespace.
This includes all chars with "whitespace" syntax (Space), and, if
parse-sexp-ignore-comments is non-nil, all characters within comments.

arguments:()
Fforward-syntactic-ws
Move point forward over all syntactic whitespace.
This includes all chars with "whitespace" syntax (Space), and, if
parse-sexp-ignore-comments is non-nil, all characters within comments.

arguments:()
Fscan-lists
Scan from character number FROM by COUNT lists.
Returns the character number of the position thus found.

If DEPTH is nonzero, paren depth begins counting from that value,
only places where the depth in parentheses becomes zero
are candidates for stopping; COUNT such places are counted.
Thus, a positive value for DEPTH means go out levels.

Comments are ignored if `parse-sexp-ignore-comments' is non-nil.

If the beginning or end of (the accessible part of) the buffer is reached
and the depth is wrong, an error is signaled.
If the depth is right but the count is not used up, nil is returned.

arguments:(from count depth)
Fscan-sexps
Scan from character number FROM by COUNT balanced expressions.
If COUNT is negative, scan backwards.
Returns the character number of the position thus found.

Comments are ignored if `parse-sexp-ignore-comments' is non-nil.

If the beginning or end of (the accessible part of) the buffer is reached
in the middle of a parenthetical grouping, an error is signaled.
If the beginning or end is reached between groupings
but before count is used up, nil is returned.

arguments:(from count)
Fbackward-prefix-chars
Move point backward over any number of chars with prefix syntax.
This includes chars with "quote" or "prefix" syntax (' or p).

arguments:()
Fparse-partial-sexp
Parse Lisp syntax starting at FROM until TO; return status of parse at TO.
Parsing stops at TO or when certain criteria are met;
 point is set to where parsing stops.
If fifth arg STATE is omitted or nil,
 parsing assumes that FROM is the beginning of a function.
Value is a list of eight elements describing final state of parsing:
 1. depth in parens.
 2. character address of start of innermost containing list; nil if none.
 3. character address of start of last complete sexp terminated.
 4. non-nil if inside a string.
    (it is the character that will terminate the string.)
 5. t if inside a comment.
 6. t if following a quote character.
 7. the minimum paren-depth encountered during this scan.
 8. nil if in comment style a, or not in a comment; t if in comment style b
If third arg TARGETDEPTH is non-nil, parsing stops if the depth
in parentheses becomes equal to TARGETDEPTH.
Fourth arg STOPBEFORE non-nil means stop when come to
 any character that starts a sexp.
Fifth arg STATE is a seven-list like what this function returns.
It is used to initialize the state of the parse.

arguments:(from to &optional targetdepth stopbefore oldstate)
Vparse-sexp-ignore-comments
Non-nil means `forward-sexp', etc., should treat comments as whitespace.Vwords-include-escapes
Non-nil means `forward-word', etc., should treat escape chars part of words.Fundo-boundary
Mark a boundary between units of undo.
An undo command will stop at this point,
but another undo command will undo to the previous boundary.

arguments:()
Fprimitive-undo
Undo N records from the front of the list LIST.
Return what remains of the list.

arguments:(count list)
V   inside-undo
internal variable used to control undoFwindowp
Returns t if OBJ is a window.

arguments:(obj)
Fselected-window
Return the window that the cursor now appears in and commands apply to.

arguments:()
Fminibuffer-window
Return the window used now for minibuffers.

arguments:()
Fwindow-minibuffer-p
Returns non-nil if WINDOW is a minibuffer window.

arguments:(window)
Fpos-visible-in-window-p
Return t if position POS is currently on the screen in WINDOW.
Returns nil if that position is scrolled vertically out of view.
POS defaults to point; WINDOW, to the selected window.

arguments:(&optional pos window)
Fwindow-buffer
Return the buffer that WINDOW is displaying.

arguments:(&optional window)
Fwindow-height
Return the number of lines in WINDOW (including its mode line).

arguments:(&optional window)
Fwindow-width
Return the number of columns in WINDOW.

arguments:(&optional window)
Fwindow-hscroll
Return the number of columns by which WINDOW is scrolled from left margin.

arguments:(&optional window)
Fset-window-hscroll
Set number of columns WINDOW is scrolled from left margin to NCOL.
NCOL should be zero or positive.

arguments:(window ncol)
Fwindow-edges
Return a list of the edge coordinates of WINDOW.
(LEFT TOP RIGHT BOTTOM), all relative to 0, 0 at top left corner of screen.
RIGHT is one more than the rightmost column used by WINDOW,
and BOTTOM is one more than the bottommost row used by WINDOW
 and its mode-line.

arguments:(&optional window)
Fwindow-point
Return current value of point in WINDOW.
For a nonselected window, this is the value point would have
if that window were selected.

Note that, when WINDOW is the selected window and its buffer
is also currently selected, the value returned is the same as (point).
It would be more strictly correct to return the `top-level' value
of point, outside of any save-excursion forms.
But that is hard to define.

arguments:(&optional window)
Fwindow-start
Return position at which display currently starts in WINDOW.

arguments:(&optional window)
Fwindow-end
Return position at which display currently ends in WINDOW.

arguments:(&optional window)
Fset-window-point
Make point value in WINDOW be at position POS in WINDOW's buffer.

arguments:(window pos)
Fset-window-start
Make display in WINDOW start at position POS in WINDOW's buffer.
Optional third arg NOFORCE non-nil inhibits next redisplay
from overriding motion of point in order to display at this exact start.

arguments:(window pos &optional noforce)
Fwindow-dedicated-p
Return WINDOW's dedicated object, usually t or nil.
See also `set-window-buffer-dedicated'.

arguments:(window)
Fset-window-buffer-dedicated
Make WINDOW display BUFFER and be dedicated to that buffer.
Then Emacs will not automatically change which buffer appears in WINDOW.
If BUFFER is nil, make WINDOW not be dedicated (but don't change which
buffer appears in it currently).

arguments:(window arg)
Fwindow-display-table
Return the display-table that WINDOW is using.

arguments:(&optional window)
Fset-window-display-table
Set WINDOW's display-table to TABLE.

arguments:(window table)
Fdelete-window
Remove WINDOW from the display.  Default is selected window.
If window is the only one on the screen, the screen is destroyed.

arguments:(&optional window)
Fnext-window
Return next window after WINDOW in canonical ordering of windows.
Optional second arg MINIBUF t means count the minibuffer window
even if not active.  If MINIBUF is neither t nor nil it means
not to count the minibuffer even if it is active.
Optional third arg ALL-SCREENS t means include all windows in all visible
screens; otherwise cycle within the selected screen, with the exception that
if a global minibuffer screen is in use, all screens are used.
Optional fourth argument INVISIBLE-TOO t means also visit invisible screens.

arguments:(&optional window mini all_screens invisible_too)
Fprevious-window
Return previous window before WINDOW in canonical ordering of windows.
Optional second arg MINIBUF t means count the minibuffer window
even if not active.  If MINIBUF is neither t nor nil it means
not to count the minibuffer even if it is active.
Optional third arg ALL-SCREENS t means include all windows in all visible
screens; otherwise cycle within the selected screen, with the exception
that if a global minibuffer screen is in use, all visible screens are used.
If optional fourth argument INVISIBLE-TOO is t also visit invisible screens.

arguments:(&optional window mini all_screens invisible_too)
Fother-window
Select the ARG'th different window on this screen.
All windows on current screen are arranged in a cyclic order.
This command selects the window ARG steps away in that order.
A negative ARG moves in the opposite order.  If the optional second
argument ALL_SCREENS is non-nil, cycle through all visible screens.
If optional third argument INVISIBLE-TOO is t also search invisible screens.

arguments:(n &optional all_screens invisible_too)
Fget-lru-window
Return the window least recently selected or used for display.
If optional argument SCREENS is non-nil, search only that screen.

arguments:(&optional screens)
Fget-largest-window
Return the window largest in area.  If optional argument SCREENS
is non-nil, search only that screen.

arguments:(&optional screens)
Fget-buffer-window
Return a window currently displaying BUFFER, or nil if none.
Only the selected screen is searched; if the optional second argument
SCREEN is non-nil, then that screen is searched instead.  If SCREEN is t,
then all visible screens are searched.  If FORCE is t invisible screens
are searched too.

arguments:(buffer &optional screen force)
Fdelete-other-windows
Make WINDOW (or the selected window) fill its screen.

arguments:(&optional window)
Fdelete-windows-on
Delete all windows showing BUFFER.

arguments:(buffer)
Freplace-buffer-in-windows
Replace BUFFER with some other buffer in all windows showing it.

arguments:(buffer)
Fset-window-buffer
Make WINDOW display BUFFER as its contents.
BUFFER can be a buffer or buffer name.

arguments:(window buffer)
Fselect-window
Select WINDOW.  Most editing will apply to WINDOW's buffer.
The main editor command loop selects the buffer of the selected window
before each command.

arguments:(window)
Fdisplay-buffer
Make BUFFER appear in some window on the current screen, but don't select it.
BUFFER can be a buffer or a buffer name.
If BUFFER is shown already in some window in the current screen, just uses
 that one, unless the window is the selected window and NOT_THIS_WINDOW_P
 is non-nil.
If ON_SCREEN is non-nil, display on that screen instead of the current
 screen (or the dedicated screen).
If BUFFER has a dedicated screen, display on that screen instead of the
 current screen, unless ON_SCREEN was specified.
If pop-up-windows is non-nil, and the buffer is not visible in some window
 on the target screen, then windows will be split (a new window will be
 created) if there is room.  Otherwise, the least-recently-used window will
 be reused.
Returns the window displaying BUFFER.

arguments:(buffer &optional not_this_window_p on_screen)
Fsplit-window
Split WINDOW, putting SIZE lines in the first of the pair.
WINDOW defaults to selected one and SIZE to half its size.
If optional third arg HOR-FLAG is non-nil, split side by side
and put SIZE columns in the first of the pair.

arguments:(&optional window chsize horflag)
Fenlarge-window
Make current window ARG lines bigger.
From program, optional second arg non-nil means grow sideways ARG columns.

arguments:(n &optional side)
Fshrink-window
Make current window ARG lines smaller.
From program, optional second arg non-nil means shrink sideways ARG columns.

arguments:(n &optional side)
Fscroll-up
Scroll text of current window upward ARG lines; or near full screen if no ARG.
A near full screen is `next-screen-context-lines' less than a full screen.
When calling from a program, supply a number as argument or nil.

arguments:(&optional n)
Fscroll-down
Scroll text of current window downward ARG lines; or near full screen if no ARG.
A near full screen is `next-screen-context-lines' less than a full screen.
When calling from a program, supply a number as argument or nil.

arguments:(&optional n)
Fscroll-other-window
Scroll text of next window upward ARG lines; or near full screen if no ARG.
The next window is the one below the current one; or the one at the top
if the current one is at the bottom.
When calling from a program, supply a number as argument or nil.

If in the minibuffer, `minibuf-scroll-window' if non-nil
specifies the window to scroll.
If `other-window-scroll-buffer' is non-nil, scroll the window
showing that buffer, popping the buffer up if necessary.

arguments:(&optional n)
Fscroll-left
Scroll selected window display ARG columns left.
Default for ARG is window width minus 2.

arguments:(arg)
Fscroll-right
Scroll selected window display ARG columns right.
Default for ARG is window width minus 2.

arguments:(arg)
Frecenter
Center point in window and redisplay screen.  With ARG, put point on line ARG.
The desired position of point is always relative to the current window.
Just C-u as prefix means put point in the center of the screen.
No arg (i.e., it is nil) erases the entire screen and then
redraws with point in the center.

arguments:(&optional n)
Fmove-to-window-line
Position point relative to window.
With no argument, position text at center of window.
An argument specifies screen line; zero means top of window,
negative means relative to bottom of window.

arguments:(arg)
Fset-window-configuration
Set the configuration of windows and buffers as specified by CONFIGURATION.
CONFIGURATION must be a value previously returned
by `current-window-configuration' (which see).

arguments:(arg)
Fcurrent-window-configuration
Return an object representing Emacs' current window configuration.
This describes the number of windows, their sizes and current buffers,
and for each displayed buffer, where display starts, and the positions of
point and mark.  An exception is made for point in the current buffer:
its value is -not- saved.

arguments:()
Fsave-window-excursion
Execute body, preserving window sizes and contents.
Restores which buffer appears in which window, where display starts,
as well as the current buffer.
Does not restore the value of point in current buffer.

arguments: (&rest args)
Vtemp-buffer-show-function
Non-nil means call as function to display a help buffer.
Used by `with-output-to-temp-buffer'.Vdisplay-buffer-function
If non-nil, function to call to handle `display-buffer'.
It will receive three args, the same args as display-buffer.Vpre-display-buffer-function
If non-nil, function that will be called from `display-buffer' as the
first action.  It will receive three args, the same arguments as
`display-buffer' -- the buffer, a flag which if non-nil means that the
currently selected window is not acceptable, and a screen to use (or nil,
meaning unspecified.)  This function may be used to select an appropriate
screen for the buffer, for example.  See also the variable
`display-buffer-function', which may be used to completely replace
display-buffer.Vminibuffer-scroll-window
Non-nil means it is the window that C-M-v in minibuffer should scroll.Vother-window-scroll-buffer
If non-nil, this is a buffer and \[scroll-other-window] should scroll its window.Vpop-up-windows
*Non-nil means display-buffer should make new windows.Vnext-screen-context-lines
*Number of lines of continuity when scrolling by screenfuls.Vsplit-height-threshold
*display-buffer would prefer to split the largest window if this large.
If there is only one window, it is split regardless of this value.Vwindow-min-height
*Delete any window less than this tall (including its mode line).Vwindow-min-width
*Delete any window less than this wide.Fredraw-screen
Clear screen SCREEN and output again what is supposed to appear on it.

arguments:(screen)
Fredraw-display
Redraw all screens marked as having their images garbled.

arguments:()
Fredraw-display
Clear the screen and output again what is supposed to appear on it.

arguments:()
Vglobal-mode-string
String displayed by mode-line-format's "%m" specification.Voverlay-arrow-position
Marker for where to display an arrow on top of the buffer text.
This must be the beginning of a line in order to work.
See also `overlay-arrow-string'.Voverlay-arrow-string
String to display as an arrow.  See also `overlay-arrow-position'.Vscroll-step
*The number of lines to try scrolling a window by when point moves out.
If that fails to bring point back on screen, point is centered instead.
If this is zero, point is always centered after it moves off screen.Vtruncate-partial-width-windows
*Non-nil means truncate lines in all windows less than full screen wide.Vmode-line-inverse-video
*Non-nil means use inverse video for the mode line.Vscreen-title-format
Controls the title of the X window corresponding to the selected screen.
This is the same format as `mode-line-format'.Vscreen-icon-title-format
Controls the title of the icon corresponding to the selected screen.
See also the variable `screen-title-format'Fenergize-toggle-psheet


arguments:()
Fx-create-screen
Make a new X window, which is considered a "screen" in Emacs terms.
Return an Emacs screen object representing the X window.
ALIST is an alist of screen parameters.
The value of `x-screen-defaults' is an additional alist
of default parameters which apply when not overridden by ALIST.
Optional second argument is the numerical ID of the X window to use for this
screen (in order to run Emacs on a window created by some other program).
Since this ID number is an unsigned long, you must pass it as a string.
It may be a string of decimal numbers, or a string of hex numbers beginning
with "0x".

arguments:(parms &optional lisp_window_id)
Fx-show-lineinfo-column
Make the current emacs screen have a lineinfo column.

arguments:(&optional screen)
Fx-hide-lineinfo-column
Make the given emacs screen not have a lineinfo column.

arguments:(&optional screen)
Fx-display-visual-class
Returns the visual class of the display `screen' is on.
The returned value will be one of the symbols StaticGray, GrayScale,
StaticColor, PseudoColor, TrueColor, or DirectColor.

arguments:(&optional screen)
Fx-color-display-p
Returns t if the X display of the given screen supports color.

arguments:(&optional screen)
Fx-pixel-width
Returns the width in pixels of the given screen.

arguments:(&optional screen)
Fx-pixel-height
Returns the height in pixels of the given screen.

arguments:(&optional screen)
Fx-display-pixel-width
Returns the width in pixels of the display `screen' is on.

arguments:(&optional screen)
Fx-display-pixel-height
Returns the height in pixels of the display `screen' is on.

arguments:(&optional screen)
Fx-display-planes
Returns the number of bitplanes of the display `screen' is on.

arguments:(&optional screen)
Fx-display-color-cells
Returns the number of color cells of the display `screen' is on.

arguments:(&optional screen)
Fx-server-vendor
Returns the vendor ID string of the X server `screen' is on.

arguments:(&optional screen)
Fx-server-version
Returns the version numbers of the X server `screen' is on.
The returned value is a list of three integers: the major and minor
version numbers of the X Protocol in use, and the vendor-specific release
number.  See also `x-server-vendor'.

arguments:(&optional screen)
Fx-set-screen-icon-pixmap
Set the icon-pixmap of the given screen.
This should be the name of a bitmap file, or a bitmap description list
 of the form (width height "bitmap-data").
If the optional third argument is specified, it is the bitmap to use for
 the icon-pixmap-mask (not all window managers obey this.)  If the bitmap
 is an XPM file which also contains a mask, the mask argument, if provided,
 will override the mask in the file.
WARNING: when you call this function, the pixmap of the previous icon
 of this screen (if any) is currently not freed (this is a bug).

arguments:(screen pixmap &optional mask)
Fx-grab-pointer
Grab the pointer and restrict it to its current window.  If optional
SHAPE is non-nil, change the pointer shape to that.  If second optional
argument MOUSE-ONLY is non-nil, ignore keyboard events during the grab.

arguments:(&optional shape ignore_keyboard)
Fx-ungrab-pointer
Release the pointer.

arguments:()
Fx-EnterNotify-internal
hands off

arguments:(screen)
Fx-LeaveNotify-internal
hands off

arguments:(screen)
Fx-FocusIn-internal
hands off

arguments:(screen)
Fx-FocusOut-internal
hands off

arguments:(screen)
Fx-VisibilityNotify-internal
hands off

arguments:(screen)
Fx-non-VisibilityNotify-internal
hands off

arguments:(screen)
Fx-MapNotify-internal
hands off

arguments:(screen)
Fx-UnmapNotify-internal
hands off

arguments:(screen)
Fx-rebind-key
Rebind X keysym KEYSYM, with MODIFIERS, to generate NEWSTRING.
KEYSYM is a string which conforms to the X keysym definitions found
in X11/keysymdef.h, sans the initial XK_. MODIFIERS is nil or a
list of strings specifying modifier keys such as Control_L, which must
also be depressed for NEWSTRING to appear.

arguments:(x_keysym modifiers newstring)
Fx-rebind-keys
Rebind KEYCODE to list of strings STRINGS.
STRINGS should be a list of 16 elements, one for each shift combination.
nil as element means don't change.
See the documentation of `x-rebind-key' for more information.

arguments:(keycode strings)
Fx-get-resource
Retrieve an X resource from the resource manager.
The first arg is the name of the resource to retrieve, such as "font".
The second arg is the class of the resource to retrieve, like "Font".
The third arg should be one of the symbols string, integer, or boolean,
specifying the type of object that the database is searched for.
The fourth arg is the screen to search for the resources on, defaulting
to the selected screen.

The call
    (x-get-resource "font" "Font" 'string)

is an interface to the C call

    XrmGetResource (db, "emacs.this_screen_name.font",
            "Emacs.EmacsScreen.Font",
            "String");

Therefore if you want to retrieve a deeper resource, for example,
"Emacs.foo.foreground", you need to specify the same number of links
in the class path:
    (x-get-resource "foo.foreground" "Thing.Foreground" 'string)

which is equivalent to

    XrmGetResource (db, "emacs.screen_name.foo.foreground",
            "Emacs.EmacsScreen.Thing.Foreground",
            "String");


The returned value of this function is nil if the queried resource is not
found.  If the third arg is `string', a string is returned, and if it is
`integer', an integer is returned.  If the third arg is `boolean', then the
returned value is the list (t) for true, (nil) for false, and is nil to
mean ``unspecified.''

arguments:(name class type &optional screen)
Fx-valid-color-name-p
Returns true if COLOR names a color that X knows about.
Valid color names are listed in the file /usr/lib/X11/rgb.txt, or
whatever the equivalent is on your system.

arguments:(color &optional screen)
Fx-valid-keysym-name-p
Returns true if KEYSYM names a keysym that the X library knows about.
Valid keysyms are listed in the files /usr/include/X11/keysymdef.h and in
/usr/lib/X11/XKeysymDB, or whatever the equivalents are on your system.

arguments:(keysym)
Fx-set-screen-pointer
Set the mouse cursor of SCREEN to the cursor named CURSOR-NAME,
with colors FOREGROUND and BACKGROUND.  The string may be any of the
standard cursor names from appendix B of the Xlib manual (also known as
the file <X11/cursorfont.h>) minus the XC_ prefix, or it may be a font
name and glyph index of the form "FONT fontname index [[font] index]",
or it may be a bitmap file acceptable to XmuLocateBitmapFile().
If it is a bitmap file, and if a bitmap file whose name is the name of
the cursor with "msk" exists, then it is used as the mask.  For example,
a pair of files may be named "cursor.xbm" and "cursor.xbmmsk".

arguments:(screen cursor_name &optional fg bg)
Fx-open-connection
Open a connection to an X server.
Argument ARGV is a list of strings describing the command line options.
Returns a copy of ARGV from which the arguments used by the Xt code
to open the connect have been removed.

arguments:(argv_list)
Fx-window-id
Get the ID of the X11 window. This gives us a chance to manipulate
the Emacs window from within a different program. Since the id is an
unsigned long, we return it as a string.

arguments:(screen)
Fx-close-current-connection
Close the connection to the current X server.

arguments:()
Fx-debug-mode
With a true arg, put the connection to the X server in synchronous
mode; this is slower.  False turns it off.
Do not simply call XSynchronize() from gdb; that won't work.

arguments:(arg)
Vx-gc-pointer-shape
The shape of the mouse-pointer during garbage collection.
If this is nil, then the cursor will not be changed, and echo-area messages
will be used instead.Vbar-cursor
Use vertical bar cursor if non-nil.Vx-screen-defaults
Alist of default screen-creation parameters for X-window screens.
These override what is specified in `~/.Xdefaults' but are overridden
by the arguments to the particular call to `x-create-screen'.Vdefault-screen-name
The default name to assign to newly-created screens.
This can be overridden by arguments to `x-create-screen'.
This must be a string.Vx-emacs-application-class
The X application class of the Emacs process.
This controls, among other things, the name of the `app-defaults' file
that emacs will use.  For changes to this variable to take effect, they
must be made before the connection to the X server is initialized, that is,
this variable may only be changed before emacs is dumped, or by setting it
in the file lisp/term/x-win.el.Vx-bitmap-file-path
A list of the directories in which X bitmap files may be found.
If nil, this is initialized from the "*bitmapFilePath" resource.Vx-allow-sendevents
*Non-nil means to allow synthetic events.  Nil means they are ignored.
Beware: allowing emacs to process SendEvents opens a big security hole.Fx-selection-reply-timeout-internal


arguments:(arg)
Fx-own-selection-internal
Assert an X selection of the given TYPE with the given VALUE.
TYPE is a symbol, typically PRIMARY, SECONDARY, or CLIPBOARD.
VALUE is typically a string, or a cons of two markers, but may be
anything that the functions on selection-converter-alist know about.

arguments:(selection_name selection_value)
Fx-get-selection-internal
Return text selected from some X window.
SELECTION is a symbol, typically PRIMARY, SECONDARY, or CLIPBOARD.
TYPE is the type of data desired, typically STRING.

arguments:(selection_symbol target_type)
Fx-disown-selection-internal
If we own the named selection, then disown it (make there be no selection).

arguments:(selection &optional time)
Fx-selection-owner-p
Whether the current emacs process owns the given X Selection.
The arg should be the name of the selection in question, typically one of
the symbols PRIMARY, SECONDARY, or CLIPBOARD.  (For convenience, the symbol
nil is the same as PRIMARY, and t is the same as SECONDARY.)

arguments:(&optional selection)
Fx-selection-exists-p
Whether there is an owner for the given X Selection.
The arg should be the name of the selection in question, typically one of
the symbols PRIMARY, SECONDARY, or CLIPBOARD.  (For convenience, the symbol
nil is the same as PRIMARY, and t is the same as SECONDARY.)

arguments:(&optional selection)
Fx-get-cutbuffer-internal
Returns the value of the named cutbuffer (typically CUT_BUFFER0).

arguments:(buffer)
Fx-store-cutbuffer-internal
Sets the value of the named cutbuffer (typically CUT_BUFFER0).

arguments:(buffer string)
Fx-rotate-cutbuffers-internal
Rotate the values of the cutbuffers by the given number of steps;
positive means move values forward, negative means backward.

arguments:(n)
Vselection-converter-alist
An alist associating selection-types (such as STRING and TIMESTAMP) with
functions.  These functions will be called with three args: the name of the
selection (typically PRIMARY, SECONDARY, or CLIPBOARD); a desired type to
which the selection should be converted; and the local selection value
(whatever had been passed to `x-own-selection').  These functions should
return the value to send to the X server (typically a string).  A return
value of nil means that the conversion could not be done.  A return value
which is the symbol NULL means that a side-effect was executed, and there
is no meaningful return value.Vx-lost-selection-hooks
A function or functions to be called after the X server has notified us
that we have lost the selection.  The function(s) will be called with one
argument, a symbol naming the selection (typically PRIMARY, SECONDARY, or
CLIPBOARD.)Vx-sent-selection-hooks
A function or functions to be called after we have responded to some
other client's request for the value of a selection that we own.  The
function(s) will be called with four arguments:
  - the name of the selection (typically PRIMARY, SECONDARY, or CLIPBOARD);
  - the name of the selection-type which we were requested to convert the
    selection into before sending (for example, STRING or LENGTH);
  - and whether we successfully transmitted the selection.
We might have failed (and declined the request) for any number of reasons,
including being asked for a selection that we no longer own, or being asked
to convert into a type that we don't know about or that is inappropriate.
This hook doesn't let you change the behavior of emacs's selection replies,
it merely informs you that they have happened.Vx-selection-timeout
If the selection owner doens't reply in this many seconds, we give up.
A value of 0 means wait as long as necessary.  This is initialized from the
"*selectionTimeout" resource (which is expressed in milliseconds).
Vemacs-version
Version numbers of this version of Emacs.
Vwin-emacs-version
Version number of this version of Win-Emacs.
Vemacs-build-time
Time at which Emacs was dumped out.
Femacs-version
Return string describing the version of Emacs that is running.
Vglobal-map
Default global keymap mapping Emacs keyboard input into commands.
The value is a keymap which is usually (but not necessarily) Emacs's
global map.
Vesc-map
Default keymap for ESC (meta) commands.
The normal global definition of the character ESC indirects to this keymap.
Vctl-x-map
Default keymap for C-x commands.
The normal global definition of the character C-x indirects to this keymap.
Vctl-x-4-map
Keymap for subcommands of C-x 4
Vmode-specific-map
Keymap for characters following C-c.
Fsystem-pc-os-p
Non-nil if Emacs is running on a `PC' operating system.
This is MS-DOS, Windows, Windows NT, or OS/2.  Among other things,
this means that backslashes are allowable file-name separators and
the text/binary file-type distinction applies.
Fsystem-msdos-p
Non-nil if Emacs is running under MS-DOS (or Windows).
This does not include Windows NT.
Fsystem-mswin-api-p
Non-nil if Emacs is running under Windows or Windows NT.
Vkill-buffer-hook
Function or functions to be called when a buffer is killed.
The value of this variable may be buffer-local.
The buffer about to be killed is current when this hook is run.
Fgenerate-new-buffer
Create and return a buffer with a name based on NAME.
Choose the buffer's name using `generate-new-buffer-name'.
Fone-window-p
Returns non-nil if there is only one window.
Optional arg NOMINI non-nil means don't count the minibuffer
even if it is active.
Fwalk-windows
Cycle through all visible windows, calling PROC for each one.
PROC is called with a window as argument.
Optional second arg MINIBUF t means count the minibuffer window
even if not active.  If MINIBUF is neither t nor nil it means
not to count the minibuffer even if it is active.
Optional third arg ALL-SCREENS t means include all windows in all screens;
otherwise cycle within the selected screen.
Fread-quoted-char
Like `read-char', except that if the first character read is an octal
digit, we read up to two more octal digits and return the character
represented by the octal number consisting of those digits.
Optional argument PROMPT specifies a string to use to prompt the user.
Ferror
Signal an error, making error message by passing all args to `format'.
Fbaud-rate
Obsolete function returning the value of the `baud-rate' variable.
Fsuppress-keymap
Make MAP override all normally self-inserting keys to be undefined.
Normally, as an exception, digits and minus-sign are set to make prefix args,
but optional second arg NODIGITS non-nil treats them like other chars.
Fsubstitute-key-definition
Replace OLDDEF with NEWDEF for any keys in KEYMAP now defined as OLDDEF.
In other words, OLDDEF is replaced with NEWDEF where ever it appears.
Prefix keymaps reached from KEYMAP are not checked recursively;
perhaps they ought to be.
Fsave-match-data
Execute the BODY forms, restoring the global value of the match data.
Frun-hooks
Takes hook names and runs each one in turn.  Major mode functions use this.
Each argument should be a symbol, a hook variable.
These symbols are processed in the order specified.
If a hook symbol has a non-nil value, that value may be a function
or a list of functions to be called to run the hook.
If the value is a function, it is called with no arguments.
If it is a list, the elements are called, in order, with no arguments.
Vrun-hooks
Variable by which C primitives find the function `run-hooks'.
Don't change it.
Fadd-hook
Add a function to a hook.
First argument HOOK-VAR (a symbol) is the name of a hook, second
 argument FUNCTION is the function to add.
Third (optional) argument AT-END means to add the function at the end
 of the hook list instead of the beginning.  If the function is already
 present, this has no effect.
Returns nil if FUNCTION was already present in HOOK-VAR, else new
 value of HOOK-VAR.
Fremove-hook
Remove a function from a hook, if it is present.
First argument HOOK-VAR (a symbol) is the name of a hook, second
 argument FUNCTION is the function to remove (compared with `eq').
Fmomentary-string-display
Momentarily display STRING in the buffer at POS.
Display remains until next character is typed.
If the char is EXIT-CHAR (optional third arg, default is SPC) it is swallowed;
otherwise it is then available as input (as a command if nothing else).
Display MESSAGE (optional fourth arg) in the echo area.
If MESSAGE is nil, instructions to type EXIT-CHAR are displayed there.
Fstart-process-shell-command
Start a program in a subprocess.  Return the process object for it.
Args are NAME BUFFER COMMAND &rest COMMAND-ARGS.
NAME is name for process.  It is modified if necessary to make it unique.
BUFFER is the buffer or (buffer-name) to associate with the process.
 Process output goes at end of that buffer, unless you specify
 an output stream or filter function to handle the output.
 BUFFER may be also nil, meaning that this process is not associated
 with any buffer
Third arg is command name, the name of a shell command.
Remaining arguments are the arguments for the command.
Wildcards and redirection are handle as usual in the shell.
Fuser-original-login-name
Return user's login name from original login.
This tries to remain unaffected by `su', by looking in environment variables.
Fredraw-mode-line
Force the mode-line of the current buffer to be redisplayed.
With optional non-nil ALL then force then force redisplay of all mode-lines.
Flocal-key-binding
Return the binding for command KEYS in current local keymap only.
KEYS is a string, a vector of events, or a vector of key-description lists
as described in the documentation for the `define-key' function.
The binding is probably a symbol with a function definition; see
the documentation for `lookup-key' for more information.
Fglobal-key-binding
Return the binding for command KEYS in current global keymap only.
KEYS is a string or vector of events, a sequence of keystrokes.
The binding is probably a symbol with a function definition; see
the documentation for `lookup-key' for more information.
Fglobal-set-key
Give KEY a global binding as COMMAND.
COMMAND is a symbol naming an interactively-callable function.
KEYS is a string, a vector of events, or a vector of key-description lists
as described in the documentation for the `define-key' function.
Note that if KEY has a local binding in the current buffer
that local binding will continue to shadow any global binding.
Flocal-set-key
Give KEY a local binding as COMMAND.
COMMAND is a symbol naming an interactively-callable function.
KEYS is a string, a vector of events, or a vector of key-description lists
as described in the documentation for the `define-key' function.
The binding goes in the current buffer's local map,
which is shared with other buffers in the same major mode.
Fglobal-unset-key
Remove global binding of KEY.
KEYS is a string, a vector of events, or a vector of key-description lists
as described in the documentation for the `define-key' function.
Flocal-unset-key
Remove local binding of KEY.
KEYS is a string, a vector of events, or a vector of key-description lists
as described in the documentation for the `define-key' function.
Fdefine-prefix-command
Define COMMAND as a prefix command.
A new sparse keymap is stored as COMMAND's function definition.
If second optional argument MAPVAR is not specified,
 COMMAND's value (as well as its function definition) is set to the keymap.
If a second optional argument MAPVAR is given and is not `t',
  the map is stored as its value.
Regardless of MAPVAR, COMMAND's function-value is always set to the keymap.
Vinsert-default-directory
*Non-nil means when reading a filename start with default dir in minibuffer.
Vminibuffer-completion-table
Alist or obarray used for completion in the minibuffer.
This becomes the ALIST argument to `try-completion' and `all-completions'.

The value may alternatively be a function, which is given three arguments:
  STRING, the current buffer contents;
  PREDICATE, the predicate for filtering possible matches;
  CODE, which says what kind of things to do.
CODE can be nil, t or `lambda'.
nil means to return the best completion of STRING, nil if there is none,
  or t if it is was already a unique completion.
t means to return a list of all possible completions of STRING.
`lambda' means to return t if STRING is a valid completion as it stands.
Vminibuffer-completion-predicate
Within call to `completing-read', this holds the PREDICATE argument.
Vminibuffer-completion-confirm
Non-nil => demand confirmation of completion before exiting minibuffer.
Vminibuffer-confirm-incomplete
If true, then in contexts where completing-read allows answers which
are not valid completions, an extra RET must be typed to confirm the
response.  This is helpful for catching typos, etc.
Vcompletion-auto-help
*Non-nil means automatically provide help for invalid completion input.
Venable-recursive-minibuffers
*Non-nil means to allow minibuffer commands while in the minibuffer.
More precisely, this variable makes a difference when the minibuffer window
is the selected window.  If you are in some other window, minibuffer commands
are allowed even if a minibuffer is active.
Vminibuffer-help-form
Value that `help-form' takes on inside the minibuffer.
Vminibuffer-local-map
Default keymap to use when reading from the minibuffer.
Vminibuffer-local-completion-map
Local keymap for minibuffer input with completion.
Vminibuffer-local-must-match-map
Local keymap for minibuffer input with completion, for exact match.
Vread-expression-map
Minibuffer keymap used for reading Lisp expressions.
Vread-shell-command-map
Minibuffer keymap used by shell-command and related commands.
Fread-from-minibuffer
Read a string from the minibuffer, prompting with string PROMPT.
If optional second arg INITIAL-CONTENTS is non-nil, it is a string
  to be inserted into the minibuffer before reading input.
  If INITIAL-CONTENTS is (STRING . POSITION), the initial input
  is STRING, but point is placed POSITION characters into the string.
Third arg KEYMAP is a keymap to use whilst reading;
  if omitted or nil, the default is `minibuffer-local-map'.
If fourth arg READ is non-nil, then interpret the result as a lisp object
  and return that object:
  in other words, do `(car (read-from-string INPUT-STRING))'
Fifth arg HISTORY, if non-nil, specifies a history list
  and optionally the initial position in the list.
  It can be a symbol, which is the history list variable to use,
  or it can be a cons cell (HISTVAR . HISTPOS).
  In that case, HISTVAR is the history list variable to use,
  and HISTPOS is the initial position (the position in the list
  which INITIAL-CONTENTS corresponds to).
  If HISTORY is `t', no history will be recorded.
  Positions are counted starting from 1 at the beginning of the list.
Fcompleting-read
Read a string in the minibuffer, with completion.
Args: PROMPT, TABLE, PREDICATE, REQUIRE-MATCH, INITIAL-CONTENTS, HISTORY.
PROMPT is a string to prompt with; normally it ends in a colon and a space.
TABLE is an alist whose elements' cars are strings, or an obarray.
PREDICATE limits completion to a subset of TABLE.
See `try-completion' for more details on completion, TABLE, and PREDICATE.
If REQUIRE-MATCH is non-nil, the user is not allowed to exit unless
 the input is (or completes to) an element of TABLE.
 If it is also not t, Return does not exit if it does non-null completion.
If INITIAL-CONTENTS is non-nil, insert it in the minibuffer initially.
  If it is (STRING . POSITION), the initial input
  is STRING, but point is placed POSITION characters into the string.
HISTORY, if non-nil, specifies a history list
  and optionally the initial position in the list.
  It can be a symbol, which is the history list variable to use,
  or it can be a cons cell (HISTVAR . HISTPOS).
  In that case, HISTVAR is the history list variable to use,
  and HISTPOS is the initial position (the position in the list
  which INITIAL-CONTENTS corresponds to).
  If HISTORY is `t', no history will be recorded.
  Positions are counted starting from 1 at the beginning of the list.
Completion ignores case if the ambient value of
  `completion-ignore-case' is non-nil.
Fminibuffer-complete
Complete the minibuffer contents as far as possible.
Fminibuffer-complete-and-exit
Complete the minibuffer contents, and maybe exit.
Exit if the name is valid with no completion needed.
If name was completed to a valid match,
a repetition of this command will exit.
Fself-insert-and-exit
Terminate minibuffer input.
Fexit-minibuffer
Terminate this minibuffer argument.
If minibuffer-confirm-incomplete is true, and we are in a completing-read
of some kind, and the contents of the minibuffer is not an existing
completion, requires an additional RET before the minibuffer will be exited
(assuming that RET was the character that invoked this command:
the character in question must be typed again).
Fminibuffer-complete-word
Complete the minibuffer contents at most a single word.
After one word is completed as much as possible, a space or hyphen
is added, provided that matches some possible completion.
Fdisplay-completion-list
Display the list of completions, COMPLETIONS, using `standard-output'.
Each element may be just a symbol or string
or may be a list of two strings to be printed as if concatenated.
If optional arg NOMESS is non-nil, suppress completion-specific
messages.
Fminibuffer-completion-help
Display a list of possible completions of the current minibuffer contents.
Vminibuffer-history
Default minibuffer history list.
This is used for all minibuffer input except when an alternate history
list is specified.
Vminibuffer-history-sexp-flag
Non-nil when doing history operations on `command-history'.
More generally, indicates that the history list being acted on
contains expressions rather than strings.
Vminibuffer-history-variable
History list symbol to add minibuffer values to.
Each minibuffer output is added with
  (set minibuffer-history-variable
       (cons STRING (symbol-value minibuffer-history-variable)))
Fprevious-matching-history-element
Find the previous history element that matches REGEXP.
(Previous history elements refer to earlier actions.)
With prefix argument N, search for Nth previous match.
If N is negative, find the next or Nth next match.
Fnext-matching-history-element
Find the next history element that matches REGEXP.
(The next history element refers to a more recent action.)
With prefix argument N, search for Nth next match.
If N is negative, find the previous or Nth previous match.
Fnext-history-element
Insert the next element of the minibuffer history into the minibuffer.
Fprevious-history-element
Inserts the previous element of the minibuffer history into the minibuffer.
Fread-minibuffer
Return a Lisp object read using the minibuffer.
Prompt with PROMPT.  If non-nil, optional second arg INITIAL-CONTENTS
is a string to insert in the minibuffer before reading.
Third arg HISTORY, if non-nil, specifies a history list.
Fread-string
Return a string from the minibuffer, prompting with string PROMPT.
If non-nil, optional second arg INITIAL-CONTENTS is a string to insert
in the minibuffer before reading.
Third arg HISTORY, if non-nil, specifies a history list.
Feval-minibuffer
Return value of Lisp expression read using the minibuffer.
Prompt with PROMPT.  If non-nil, optional second arg INITIAL-CONTENTS
is a string to insert in the minibuffer before reading.
Third arg HISTORY, if non-nil, specifies a history list.
Fread-command
Read the name of a command and return as a symbol.
Prompts with PROMPT.
Fread-function
Read the name of a function and return as a symbol.
Prompts with PROMPT.
Fread-variable
Read the name of a user variable and return it as a symbol.
Prompts with PROMPT.
A user variable is one whose documentation starts with a `*' character.
Fread-buffer
Read the name of a buffer and return as a string.
Prompts with PROMPT.  Optional second arg DEFAULT is value to return if user
enters an empty line.  If optional third arg REQUIRE-MATCH is non-nil,
only existing buffer names are allowed.
Fread-number
Reads a number from the minibuffer.
Fread-shell-command
Just like read-string, but uses read-shell-command-map:
\{read-shell-command-map}
Fread-file-name
Read file name, prompting with PROMPT and completing in directory DIR.
Value is not expanded---you must call `expand-file-name' yourself.
Value is subject to interpreted by substitute-in-file-name however.
Default name to DEFAULT if user enters a null string.
 (If DEFAULT is omitted, the visited file name is used.)
Fourth arg MUST-MATCH non-nil means require existing file's name.
 Non-nil and non-t means also require confirmation after completion.
Fifth arg INITIAL-CONTENTS specifies text to start with.
Sixth arg HISTORY specifies the history list to use.  Default is
 `minibuffer-file-name-history'.
DIR defaults to current buffer's directory default.
Fy-or-n-p-minibuf
Ask user a "y or n" question.  Return t if answer is "y".
Takes one argument, which is the string to display to ask the question.
It should end in a space; `y-or-n-p' adds `(y or n) ' to it.
No confirmation of the answer is requested; a single character is enough.
Also accepts Space to mean yes, or Delete to mean no.
Fyes-or-no-p-minibuf
Ask user a yes-or-no question.  Return t if answer is yes.
Takes one argument, which is the string to display to ask the question.
It should end in a space; `yes-or-no-p' adds `(yes or no) ' to it.
The user must confirm the answer with RET,
and can edit it until it as been confirmed.
Vglobal-face-data
do not use this
Vface-id-tick
don't even think of using this
Flist-faces
Returns a list of the names of all of the defined faces.
Ffind-face
Retrieve the face of the given name.
If NAME is a symbol and SCREEN is provided, the face is looked up on
that screen; otherwise, the selected screen is used.
If there is no such face, returns nil.
If SCREEN is the symbol t, then the global, non-screen face is returned.
If NAME is already a face, it is simply returned.
Fget-face
Retrieve the face of the given name.
If NAME is a symbol and SCREEN is provided, the face is looked up on
that screen; otherwise, the selected screen is used.
If there is no such face, an error is signalled.  See also `find-face'.
If SCREEN is the symbol t, then the global, non-screen face is returned.
If NAME is already a face, it is simply returned.
Fface-name
Returns the name of the given face.
Fface-id
Returns the internal ID number of the given face.
Fface-font
Returns the font name of the given face, or nil if it is unspecified.
Fface-foreground
Returns the foreground color name of the given face, or nil if unspecified.
Fface-background
Returns the background color name of the given face, or nil if unspecified.
Fface-background-pixmap
Returns the background pixmap name of the given face, or nil if unspecified.
Fface-underline-p
Returns whether the given face is underlined.
Fset-face-font
Change the font of the given face.  The font should be a string, the name
string, the name of the font.  If the optional SCREEN argument is provided,
this face will be changed only in that screen; otherwise it will be changed
in all screens.
Fset-face-foreground
Change the foreground color of the given face.  The color should be a
string, the name of a color.  If the optional SCREEN argument is provided,
this face will be changed only in that screen; otherwise it will be changed
in all screens.
Fset-face-background
Change the background color of the given face.  The color should be a
string, the name of a color.  If the optional SCREEN argument is provided,
this face will be changed only in that screen; otherwise it will be changed
in all screens.
Fset-face-background-pixmap
Change the background pixmap of the given face.  The pixmap name should be
a string, the name of a file of pixmap data.  The directories listed in the
x-bitmap-file-path variable will be searched.  The bitmap may also be a list
of the form (width height data) where width and height are the size in pixels,
and data is a string, containing the raw bits of the bitmap.
If the optional SCREEN argument is provided, this face will be changed only
in that screen; otherwise it will be changed in all screens.
Fset-face-underline-p
Change whether the given face is underlined.
If the optional SCREEN argument is provided, this face will be changed only
in that screen; otherwise it will be changed in all screens.
Fmake-face
Defines and returns a new FACE on all screens.
You can modify the font, color, etc of this face with the set-face- functions.
If the face already exists, it is unmodified.
Fcopy-face
Defines and returns a new face which is a copy of an existing one,
or makes an already-existing face be exactly like another.
Fset-extent-face
Make the given EXTENT have the graphic attributes specified by FACE.
Fextent-face
Returns the name of the face in which EXTENT is displayed.
Fface-equal
True if the given faces will display in the the same way.
Fface-differs-from-default-p
True if the given face will display differently from the default face.
A face is considered to be ``the same'' as the default face if it is
actually specified in the same way (equivalent fonts, etc) or if it is
fully unspecified, and thus will inherit the attributes of any face it
is displayed on top of.
Finvert-face
Swap the foreground and background colors of the given face.
If the face doesn't specify both foreground and background, then
its foreground and background are set to the background and
foreground of the default face.
Ftry-face-font
Like set-face-font, but returns nil on failure instead of an error.
Fset-default-font
Sets the font used for normal text and the modeline to FONT in all screens.
For finer-grained control, use set-face-font.
Vmode-line-buffer-identification
Mode-line control for identifying the buffer being displayed.
Its default value is "Emacs: %17b".  Major modes that edit things
other than ordinary files may change this (e.g. Info, Dired,...)
Vmode-line-process
Mode-line control for displaying info on process status.
Normally nil in most modes, since there is no process to display.
Vmode-line-modified
Mode-line control for displaying whether current buffer is modified.
Vminor-mode-alist
Alist saying how to show minor modes in the mode line.
Each element looks like (VARIABLE STRING);
STRING is included in the mode line iff VARIABLE's value is non-nil.
Vparagraph-start
*Regexp for beginning of a line that starts OR separates paragraphs.
Vparagraph-separate
*Regexp for beginning of a line that separates paragraphs.
If you change this, you may have to change paragraph-start also.
Vsentence-end
*Regexp describing the end of a sentence.
All paragraph boundaries also end sentences, regardless.
Vpage-delimiter
*Regexp describing line-beginnings that separate pages.
Vcase-replace
*Non-nil means query-replace should preserve case in replacements.
Vindent-line-function
Function to indent current line.
Vonly-global-abbrevs
*t means user plans to use global abbrevs only.
Makes the commands to define mode-specific abbrevs define global ones instead.
Vgrep-command
*Name of the command to use to run the grep command;
typically "grep -n" or "egrep -n".
(The "-n" option tells grep to output line numbers.)
Vdired-listing-switches
*Switches passed to `ls' for Dired.  MUST contain the `l' option.
Vlpr-switches
*List of strings to pass as extra args to `lpr' when it is invoked.
Vtag-table-alist
*A list which determines which tags files should be active for a
given buffer.  This is not really an association list, in that all
elements are checked.  The CAR of each element of this list is a
pattern against which the buffer's file name is compared; if it
matches, then the CDR of the list should be the name of the tags
table to use.  If more than one element of this list matches the
buffer's file name, then all of the associated tags tables will be
used.  Earlier ones will be searched first.

If the CAR of elements of this list are strings, then they are treated
as regular-expressions against which the file is compared (like the
auto-mode-alist).  If they are not strings, then they are evaluated.
If they evaluate to non-nil, then the current buffer is considered to
match.

If the CDR of the elements of this list are strings, then they are
assumed to name a TAGS file.  If they name a directory, then the string
"TAGS" is appended to them to get the file name.  If they are not
strings, then they are evaluated, and must return an appropriate string.

For example:
  (setq tag-table-alist
    '(("/usr/src/public/perl/" . "/usr/src/public/perl/perl-3.0/")
     ("\\.el$" . "/usr/local/emacs/src/")
     ("/jbw/gnu/" . "/usr15/degree/stud/jbw/gnu/")
     ("" . "/usr/local/emacs/src/")
     ))

This means that anything in the /usr/src/public/perl/ directory should use
the TAGS file /usr/src/public/perl/perl-3.0/TAGS; and file ending in .el should
use the TAGS file /usr/local/emacs/src/TAGS; and anything in or below the
directory /jbw/gnu/ should use the TAGS file /usr15/degree/stud/jbw/gnu/TAGS.
A file called something like "/usr/jbw/foo.el" would use both the TAGS files
/usr/local/emacs/src/TAGS and /usr15/degree/stud/jbw/gnu/TAGS (in that order)
because it matches both patterns.

If the buffer-local variable `buffer-tag-table' is set, then it names a tags
table that is searched before all others when find-tag is executed from this
buffer.

If there is a file called "TAGS" in the same directory as the file in
question, then that tags file will always be used as well (after the
`buffer-tag-table' but before the tables specified by this list.)

If the variable tags-file-name is set, then the tags file it names will apply
to all buffers (for backwards compatibility.)  It is searched first.

Vtags-file-name
*The name of the tags-table used by all buffers.
This is for backward compatibility, and is largely supplanted by the
variable tag-table-alist.
Vshell-prompt-pattern
*Regexp used by Newline command in shell mode to match subshell prompts.
Anything from beginning of line up to the end of what this pattern matches
is deemed to be prompt, and is not reexecuted.
Vledit-save-files
*Non-nil means Ledit should save files before transferring to Lisp.
Vledit-go-to-lisp-string
*Shell commands to execute to resume Lisp job.
Vledit-go-to-liszt-string
*Shell commands to execute to resume Lisp compiler job.
Vdisplay-time-day-and-date
*Non-nil means M-x display-time should display day and date as well as time.
Vauto-mode-alist
Alist of filename patterns vs corresponding major mode functions.
Each element looks like (REGEXP . FUNCTION).
Visiting a file whose name matches REGEXP causes FUNCTION to be called.
Fadd-change-log-entry
Find change log file and add an entry for today.
First arg (interactive prefix) non-nil means prompt for user name and site.
Second arg is file name of change log.
Optional third arg OTHER-WINDOW non-nil means visit in other window.
Fadd-change-log-entry-other-window
Find change log file in other window, and add an entry for today.
Fapropos
Show all symbols whose names contain matches for REGEXP.
If optional argument DO-ALL is non-nil, does more (time-consuming) work such as
showing key bindings.  Optional argument PRED is called with each symbol, and
if it returns nil, the symbol is not shown.  Returns list of symbols and
documentation found.
Fsuper-apropos
Show symbols whose names/documentation contain matches for REGEXP.
If optional argument DO-ALL is non-nil, does more (time-consuming) work such as
showing key bindings and documentation that is not stored in the documentation
file.  Returns list of symbols and documentation found.
Fawk-mode
Major mode for editing AWK code.
This is much like C mode except for the syntax of comments.
It uses the same keymap as C mode and has the same variables
for customizing indentation.  It has its own abbrev table
and its own syntax table.

Turning on AWK mode calls the value of the variable `awk-mode-hook'
with no args, if that value is non-nil.
F`
(` FORM)  is a macro that expands to code to construct FORM.
Note that this is very slow in interpreted code, but fast if you compile.
FORM is one or more nested lists, which are `almost quoted':
They are copied recursively, with non-lists used unchanged in the copy.
 (` a b) == (list 'a 'b)  constructs a new list with two elements, `a' and `b'.
 (` a (b c)) == (list 'a (list 'b 'c))  constructs two nested new lists.

However, certain special lists are not copied.  They specify substitution.
Lists that look like (, EXP) are evaluated and the result is substituted.
 (` a (, (+ x 5))) == (list 'a (+ x 5))

Elements of the form (,@ EXP) are evaluated and then all the elements
of the result are substituted.  This result must be a list; it may
be `nil'.

As an example, a simple macro `push' could be written:
   (defmacro push (v l)
        (` (setq (, l) (cons (,@ (list v l))))))
or as
   (defmacro push (v l)
        (` (setq (, l) (cons (, v) (, l)))))

LIMITATIONS: "dotted lists" are not allowed in FORM.
The ultimate cdr of each list scanned by ` must be `nil'.
(This does not apply to constants inside expressions to be substituted.)

Substitution elements are not allowed as the cdr
of a cons cell.  For example, (` (A . (, B))) does not work.
Instead, write (` (A (,@ B))).

You cannot construct vectors, only lists.  Vectors are treated as
constants.

BEWARE BEWARE BEWARE
Inclusion of (,ATOM) rather than (, ATOM)
or of (,@ATOM) rather than (,@ ATOM)
will result in errors that will show up very late.
Fbyte-compile-file
Compile a file of Lisp code named FILENAME into a file of byte code.
The output file's name is made by appending "c" to the end of FILENAME.
With prefix arg (noninteractively: 2nd arg), load the file after compiling.
Fbyte-compile-and-load-file
Compile a file of Lisp code named FILENAME into a file of byte code,
and then load it.  The output file's name is made by appending "c" to
the end of FILENAME.
Fbyte-compile-buffer
Byte-compile and evaluate contents of BUFFER (default: the current buffer).
Felisp-compile-defun
Compile and evaluate the current top-level form.
Print the result in the minibuffer.
With argument, insert value in current buffer after the form.
Fbyte-recompile-directory
Recompile every `.el' file in DIRECTORY that needs recompilation.
This is if a `.elc' file exists but is older than the `.el' file.

If the `.elc' file does not exist, normally the `.el' file is *not* compiled.
But a prefix argument (optional second arg) means ask user,
for each such `.el' file, whether to compile it.
Fbatch-byte-compile
Runs byte-compile-file on the files remaining on the command line.
Must be used only with -batch, and kills emacs on completion.
Each file will be processed even if an error occurred previously.
For example, invoke "emacs -batch -f batch-byte-compile $emacs/ ~/*.el"
Fbatch-byte-recompile-directory
Runs `byte-recompile-directory' on the dirs remaining on the command line.
Must be used only with -batch, and kills emacs on completion.
For example, invoke "emacs -batch -f batch-byte-recompile-directory ."
Fset-c-style
Specify a style of indentation for C code for the current buffer.
The argument STYLE should be a standard style name defined in
`c-style-alist', such as GNU, BSD, K&R, etc.  (These are Lisp symbols.)
An omitted arg, or nil, means to use the value of `default-c-style'.

Setting the style sets various C-mode customization parameters accordingly,
all local to the current buffer.
Ffont-lock-mode
Toggle Font Lock Mode.
With arg, turn font-lock mode on if and only if arg is positive.
In the font-lock minor mode, text is fontified as you type it:

 - comments are displayed in font-lock-comment-face;
 - strings are displayed in font-lock-string-face;
 - documentation strings are displayed in font-lock-doc-string-face;
 - function and variable names in their defining forms are displayed
   in font-lock-function-name-face;
 - and certain other expressions are displayed in other faces
   according to the value of the variable `font-lock-keywords'.

When font-lock mode is turned on/off, the buffer is fontified/defontified.
To fontify a buffer without having newly typed text become fontified, you
can use \[font-lock-fontify-buffer].
Ffont-lock-fontify-buffer
Fontify the current buffer the way `font-lock-mode' would:

 - comments are displayed in font-lock-comment-face;
 - strings are displayed in font-lock-string-face;
 - documentation strings are displayed in font-lock-doc-string-face;
 - function and variable names in their defining forms are displayed
   in font-lock-function-name-face;
 - and certain other expressions are displayed in other faces
   according to the value of the variable `font-lock-keywords'.

This can take a while for large buffers.
Vfont-lock-keywords
*The keywords to highlight.
If this is a list, then elements may be of the forms:

  "string"            ; a regexp to highlight in the
                ;  `font-lock-keyword-face'.
  ("string" . integer)      ; match N of the regexp will be highlighted
  ("string" . face-name)    ; use the named face
  ("string" integer face-name)  ; both of the above

These regular expressions should not match text which spans lines.  Multi-line
patterns will be correctly fontified when \[font-lock-fontify-buffer] is used,
but will not be matched by the auto-fontification that font-lock-mode does,
since it looks at only one line at a time.

The more patterns there are in this list, the slower the initial fontification
of the buffer will be.
Fholidays
Prepare a list of holidays in the previous, present, and next months.
Fcalendar
Display a three-month calendar window.
Fdiary
Display a window of diary entries.
Fphases-of-moon
Display the quarters of the moon for last month, this month, and next month.
This function is suitable for execution in a .emacs file.
Fsunrise-sunset
Local time of sunrise and sunset for today.  Accurate to +/- 2 minutes.
Fdiff
Find and display the differences between OLD and NEW files.
Interactively you are prompted with the current buffer's file name for NEW
and what appears to be it's backup for OLD.
Vdiff-switches
*A list of switches to pass to the diff program.
Vkill-emacs-hook
A list of functions (of no args) for `kill-emacs' to call before emacs is
actually killed.
Flist-command-history
List history of commands typed to minibuffer.
The number of commands listed is controlled by  list-command-history-max.
Calls value of  list-command-history-filter  (if non-nil) on each history
element to judge if that element should be excluded from the list.

The buffer is left in Command History mode.
Fcommand-history-mode
Major mode for examining commands from  command-history.
The number of commands listed is controlled by  list-command-history-max.
The command history is filtered by  list-command-history-filter  if non-nil.

Like Emacs-Lisp Mode except that characters do not insert themselves and
Digits provide prefix arguments.  Tab does not indent.
\{command-history-map}
Calls the value of  command-history-hook  if that is non-nil
The Command History listing is recomputed each time this mode is
invoked.
Frepeat-matching-complex-command
Edit and re-evaluate complex command with name matching PATTERN.
Matching occurrences are displayed, most recent first, until you
select a form for evaluation.  If PATTERN is empty (or nil), every form
in the command history is offered.  The form is placed in the minibuffer
for editing and the result is evaluated.
Fcommon-lisp-indent-function

Fcompare-windows
Compare text in current window with text in next window.
Compares the text starting at point in each window,
moving over text in each one as far as they match.
Fcompile
Compile the program including the current buffer.  Default: run `make'.
Runs COMMAND, a shell command, in a separate process asynchronously
with output going to the buffer *compilation*.
You can then use the command \[next-error] to find the next error message
and move to the source code that caused it.
Fgrep
Run grep, with user-specified args, and collect output in a buffer.
While grep runs asynchronously, you can use the \[next-error] command
to find the text that grep hits refer to.
Fnext-error
Visit next compilation error message and corresponding source code.
This operates on the output from the \[compile] command.
If all preparsed error messages have been processed,
the error message buffer is checked for new ones.
A non-nil argument (prefix arg, if interactive)
means reparse the error message buffer and start at the first error.
Fprevious-error
See \[next-error].
Fdabbrev-expand
Expand previous word "dynamically".
Expands to the most recent, preceding word for which this is a prefix.
If no suitable preceding word is found, words following point are considered.

A positive prefix argument, N, says to take the Nth backward DISTINCT
possibility.  A negative argument says search forward.  The variable
dabbrev-backward-only may be used to limit the direction of search to
backward if set non-nil.

If the cursor has not moved from the end of the previous expansion and
no argument is given, replace the previously-made expansion
with the next possible expansion not yet tried.
Fdebug
Enter debugger.  Returns if user says "continue".
Arguments are mainly for use when this is called
 from the internals of the evaluator.
You may call with no args, or you may
 pass nil as the first arg and any other args you like.
 In that case, the list of args after the first will
 be printed into the backtrace buffer.
Fcancel-debug-on-entry
Undo effect of debug-on-entry on FUNCTION.
Fdebug-on-entry
Request FUNCTION to invoke debugger each time it is called.
If the user continues, FUNCTION's execution proceeds.
Works by modifying the definition of FUNCTION,
which must be written in Lisp, not predefined.
Use `cancel-debug-on-entry' to cancel the effect of this command.
Redefining FUNCTION also does that.
Fdired
"Edit" directory DIRNAME--delete, rename, print, etc. some files in it.
Dired displays a list of files in DIRNAME.
You can move around in it with the usual commands.
You can flag files for deletion with C-d
and then delete them by typing `x'.
Type `h' after entering dired for more info.
Fdired-other-window
"Edit" directory DIRNAME.  Like \[dired] but selects in another window.
Fdired-noselect
Like M-x dired but returns the dired buffer as value, does not select it.
Fdissociated-press
Dissociate the text of the current buffer.
Output goes in buffer named *Dissociation*,
which is redisplayed each time text is added to it.
Every so often the user must say whether to continue.
If ARG is positive, require ARG chars of continuity.
If ARG is negative, require -ARG words of continuity.
Default is 2.
Fdoctor
Switch to *doctor* buffer and start giving psychotherapy.
Fdisassemble
Print disassembled code for OBJECT on (optional) STREAM.
OBJECT can be a symbol defined as a function, or a function itself
(a lambda expression or a compiled-function object).
If OBJECT is not already compiled, we compile it, but do not
redefine OBJECT if it is a symbol.
Felectric-buffer-list
Vaguely like ITS lunar select buffer;
combining typeoutoid buffer listing with menuoid buffer selection.

This pops up a buffer describing the set of emacs buffers.
If the very next character typed is a space then the buffer list
 window disappears.

Otherwise, one may move around in the buffer list window, marking
 buffers to be selected, saved or deleted.

To exit and select a new buffer, type Space when the cursor is on the
 appropriate line of the buffer-list window.

Other commands are much like those of buffer-menu-mode.

Calls value of  electric-buffer-menu-mode-hook  on entry if non-nil.

\{electric-buffer-menu-mode-map}
Felectric-command-history
Major mode for examining and redoing commands from  command-history.
The number of command listed is controlled by  list-command-history-max.
The command history is filtered by  list-command-history-filter  if non-nil.
Combines typeout Command History list window with menu like selection
of an expression from the history for re-evaluation in the *original* buffer.

The history displayed is filtered by  list-command-history-filter  if non-nil.

This pops up a window with the Command History listing.  If the very
next character typed is Space, the listing is killed and the previous
window configuration is restored.  Otherwise, you can browse in the
Command History with  Return  moving down and  Delete  moving up, possibly
selecting an expression to be redone with Space or quitting with `Q'.

Like Emacs-Lisp Mode except that characters do not insert themselves and
Tab and linefeed do not indent.  Instead these commands are provided:
Space or !    edit then evaluate current line in history inside
           the ORIGINAL buffer which invoked this mode.
           The previous window configuration is restored
           unless the invoked command changes it.
C-c C-c, C-], Q    Quit and restore previous window configuration.
LFD, RET    Move to the next line in the history.
DEL        Move to the previous line in the history.
?        Provides a complete list of commands.

Calls the value of  electric-command-history-hook  if that is non-nil
The Command History listing is recomputed each time this mode is invoked.
Fedt-emulation-on
Begin emulating DEC's EDT editor.
Certain keys are rebound; including nearly all keypad keys.
Use \[edt-emulation-off] to undo all rebindings except the keypad keys.
Note that this function does not work if called directly from the .emacs file.
Instead, the .emacs file should do (setq term-setup-hook 'edt-emulation-on)
Then this function will be called at the time when it will work.
Ffortran-mode
Major mode for editing fortran code.
Tab indents the current fortran line correctly.
`do' statements must not share a common `continue'.

Type `;?' or `;\[help-command]' to display a list of built-in abbrevs for Fortran keywords.

Variables controlling indentation style and extra features:

 comment-start
    Normally nil in Fortran mode.  If you want to use comments
    starting with `!', set this to the string "!".
 fortran-do-indent
    Extra indentation within do blocks.  (default 3)
 fortran-if-indent
    Extra indentation within if blocks.  (default 3)
 fortran-continuation-indent
    Extra indentation appled to continuation statements.  (default 5)
 fortran-comment-line-column
    Amount of indentation for text within full-line comments. (default 6)
 fortran-comment-indent-style
    nil    means don't change indentation of text in full-line comments,
    fixed  means indent that text at column fortran-comment-line-column
    relative  means indent at fortran-comment-line-column beyond the
           indentation for a line of code.
    Default value is fixed.
 fortran-comment-indent-char
    Character to be inserted instead of space for full-line comment
    indentation.  (default is a space)
 fortran-minimum-statement-indent
    Minimum indentation for fortran statements. (default 6)
 fortran-line-number-indent
    Maximum indentation for line numbers.  A line number will get
    less than this much indentation if necessary to avoid reaching
    column 5.  (default 1)
 fortran-check-all-num-for-matching-do
    Non-nil causes all numbered lines to be treated as possible 'continue'
    statements.  (default nil)
 fortran-continuation-char
    character to be inserted in column 5 of a continuation line.
    (default $)
 fortran-comment-region
    String inserted by \[fortran-comment-region] at start of each line in
    region.  (default "c$$$")
 fortran-electric-line-number
    Non-nil causes line number digits to be moved to the correct column
    as typed.  (default t)
 fortran-startup-message
    Set to nil to inhibit message first time fortran-mode is used.

Turning on Fortran mode calls the value of the variable fortran-mode-hook
with no args, if that value is non-nil.
\{fortran-mode-map}
Fgdb
Run gdb on program FILE in buffer *gdb-FILE*.
The directory containing FILE becomes the initial working directory
and source-file directory for GDB.  If you wish to change this, use
the GDB commands `cd DIR' and `directory'.
Fset-gosmacs-bindings
Rebind some keys globally to make GNU Emacs resemble Gosling Emacs.
Use \[set-gnu-bindings] to restore previous global bindings.
Fhanoi
Towers of Hanoi diversion.  Argument is number of rings.
FHelper-help
Provide help for current mode.
FHelper-describe-bindings
Describe local key bindings of current mode.
Finfo
Enter Info, the documentation browser.
FInfo-tagify
Create or update Info-file tag table in current buffer.
FInfo-validate
Check current buffer for validity as an Info file.
Check that every node pointer points to an existing node.
FInfo-split
Split an info file into an indirect file plus bounded-size subfiles.
Each subfile will be up to 50000 characters plus one node.

To use this command, first visit a large Info file that has a tag table.
The buffer is modified into a (small) indirect info file
which should be saved in place of the original visited file.

The subfiles are written in the same directory the original file is in,
with names generated by appending `-' and a number to the original file name.

The indirect file still functions as an Info file, but it contains
just the tag table and a directory of subfiles.
Fbatch-info-validate
Runs  Info-validate  on the files remaining on the command line.
Must be used only with -batch, and kills emacs on completion.
Each file will be processed even if an error occurred previously.
For example, invoke "emacs -batch -f batch-info-validate $info/ ~/*.info"
Fledit-mode
Major mode for editing text and stuffing it to a Lisp job.
Like Lisp mode, plus these special commands:
  M-C-d    -- record defun at or after point
       for later transmission to Lisp job.
  M-C-r -- record region for later transmission to Lisp job.
  C-x z -- transfer to Lisp job and transmit saved text.
  M-C-c -- transfer to Liszt (Lisp compiler) job
       and transmit saved text.
\{ledit-mode-map}
To make Lisp mode automatically change to Ledit mode,
do (setq lisp-mode-hook 'ledit-from-lisp-mode)
Fledit-from-lisp-mode

Flpr-buffer
Print buffer contents as with Unix command `lpr'.
`lpr-switches' is a list of extra switches (strings) to pass to lpr.
Fprint-buffer
Print buffer contents as with Unix command `lpr -p'.
`lpr-switches' is a list of extra switches (strings) to pass to lpr.
Flpr-region
Print region contents as with Unix command `lpr'.
`lpr-switches' is a list of extra switches (strings) to pass to lpr.
Fprint-region
Print region contents as with Unix command `lpr -p'.
`lpr-switches' is a list of extra switches (strings) to pass to lpr.
Finsert-kbd-macro
Insert in buffer the definition of kbd macro NAME, as Lisp code.
Second argument KEYS non-nil means also record the keys it is on.
 (This is the prefix argument, when calling interactively.)

This Lisp code will, when executed, define the kbd macro with the
same definition it has now.  If you say to record the keys,
the Lisp code will also rebind those keys to the macro.
Only global key bindings are recorded since executing this Lisp code
always makes global bindings.

To save a kbd macro, visit a file of Lisp code such as your ~/.emacs,
use this command, and then save the file.
Fkbd-macro-query
Query user during kbd macro execution.
With prefix argument, enters recursive edit,
 reading keyboard commands even within a kbd macro.
 You can give different commands each time the macro executes.
Without prefix argument, reads a character.  Your options are:
 Space -- execute the rest of the macro.
 DEL -- skip the rest of the macro; start next repetition.
 C-d -- skip rest of the macro and don't repeat it any more.
 C-r -- enter a recursive edit, then on exit ask again for a character
 C-l -- redisplay screen and ask again.
Fname-last-kbd-macro
Assign a name to the last keyboard macro defined.
One arg, a symbol, which is the name to define.
The symbol's function definition becomes the keyboard macro string.
Such a "function" cannot be called from Lisp, but it is a valid command
definition for the editor command loop.
Fmake-command-summary
Make a summary of current key bindings in the buffer *Summary*.
Previous contents of that buffer are killed first.
Fdefine-mail-alias
Define NAME as a mail-alias that translates to DEFINITION.
If DEFINITION contains multiple addresses, seperate them with commas.
Fmanual-entry
Display the Unix manual entry for TOPIC.
TOPIC is either the title of the entry, or has the form TITLE(SECTION)
where SECTION is the desired section of the manual, as in `tty(4)'.
Fmh-rmail
Inc(orporate) new mail (no arg) or scan a MH mail box (arg given).
This front end uses the MH mail system, which uses different conventions
from the usual mail system.
Fmh-smail
Send mail using the MH mail system.
Fconvert-mocklisp-buffer
Convert buffer of Mocklisp code to real Lisp that GNU Emacs can run.
Fmodula-2-mode
This is a mode intended to support program development in Modula-2.
All control constructs of Modula-2 can be reached by typing
Control-C followed by the first character of the construct.
\{m2-mode-map}
  Control-c b begin         Control-c c case
  Control-c d definition    Control-c e else
  Control-c f for           Control-c h header
  Control-c i if            Control-c m module
  Control-c l loop          Control-c o or
  Control-c p procedure     Control-c Control-w with
  Control-c r record        Control-c s stdio
  Control-c t type          Control-c u until
  Control-c v var           Control-c w while
  Control-c x export        Control-c y import
  Control-c { begin-comment Control-c } end-comment
  Control-c Control-z suspend-emacs     Control-c Control-t toggle
  Control-c Control-c compile           Control-x ` next-error
  Control-c Control-l link

   m2-indent controls the number of spaces for each indentation.
   m2-compile-command holds the command to compile a Modula-2 program.
   m2-link-command holds the command to link a Modula-2 program.
Fdisabled-command-hook

Fenable-command
Allow COMMAND to be executed without special confirmation from now on.
The user's .emacs file is altered so that this will apply
to future sessions.
Fdisable-command
Require special confirmation to execute COMMAND from now on.
The user's .emacs file is altered so that this will apply
to future sessions.
Fnroff-mode
Major mode for editing text intended for nroff to format.
\{nroff-mode-map}
Turning on Nroff mode runs text-mode-hook, then nroff-mode-hook.
Also, try nroff-electric-mode, for automatically inserting
closing requests for requests that are used in matched pairs.
Flist-options
Display a list of Emacs user options, with values and documentation.
Fedit-options
Edit a list of Emacs user option values.
Selects a buffer containing such a list,
in which there are commands to set the option values.
Type \[describe-mode] in that buffer for a list of commands.
Foutline-mode
Set major mode for editing outlines with selective display.
Headings are lines which start with asterisks: one for major headings,
two for subheadings, etc.  Lines not starting with asterisks are body lines.

Body text or subheadings under a heading can be made temporarily
invisible, or visible again.  Invisible lines are attached to the end
of the heading, so they move with it, if the line is killed and yanked
back.  A heading with text hidden under it is marked with an ellipsis (...).

Commands:
C-c C-n   outline-next-visible-heading      move by visible headings
C-c C-p   outline-previous-visible-heading
C-c C-f   outline-forward-same-level        similar but skip subheadings
C-c C-b   outline-backward-same-level
C-c C-u   outline-up-heading            move from subheading to heading

Meta-x hide-body    make all text invisible (not headings).
Meta-x show-all        make everything in buffer visible.

The remaining commands are used when point is on a heading line.
They apply to some of the body or subheadings of that heading.
C-c C-h   hide-subtree    make body and subheadings invisible.
C-c C-s   show-subtree    make body and subheadings visible.
C-c C-i   show-children    make direct subheadings visible.
         No effect on body, or subheadings 2 or more levels down.
         With arg N, affects subheadings N levels down.
M-x hide-entry       make immediately following body invisible.
M-x show-entry       make it visible.
M-x hide-leaves       make body under heading and under its subheadings invisible.
             The subheadings remain visible.
M-x show-branches  make all subheadings at all levels visible.

The variable outline-regexp can be changed to control what is a heading.
A line is a heading if outline-regexp matches something at the
beginning of the line.  The longer the match, the deeper the level.

Turning on outline mode calls the value of text-mode-hook and then of
outline-mode-hook, if they are non-nil.
Fcvs-update
Run a 'cvs update' in the current working directory. Feed the
output to a *cvs* buffer and run cvs-mode on it.
If optional prefix argument LOCAL is non-nil, 'cvs update -l' is run.
Fcvs-update-other-window
Run a 'cvs update' in the current working directory. Feed the
output to a *cvs* buffer, display it in the other window, and run
cvs-mode on it.

If optional prefix argument LOCAL is non-nil, 'cvs update -l' is run.
Fedit-picture
Switch to Picture mode, in which a quarter-plane screen model is used.
Printing characters replace instead of inserting themselves with motion
afterwards settable by these commands:
  C-c <      Move left after insertion.
  C-c >      Move right after insertion.
  C-c ^      Move up after insertion.
  C-c .      Move down after insertion.
  C-c `      Move northwest (nw) after insertion.
  C-c '      Move northeast (ne) after insertion.
  C-c /      Move southwest (sw) after insertion.
  C-c \   Move southeast (se) after insertion.
The current direction is displayed in the mode line.  The initial
direction is right.  Whitespace is inserted and tabs are changed to
spaces when required by movement.  You can move around in the buffer
with these commands:
  C-p      Move vertically to SAME column in previous line.
  C-n      Move vertically to SAME column in next line.
  C-e      Move to column following last non-whitespace character.
  C-f      Move right inserting spaces if required.
  C-b      Move left changing tabs to spaces if required.
  C-c C-f Move in direction of current picture motion.
  C-c C-b Move in opposite direction of current picture motion.
  Return  Move to beginning of next line.
You can edit tabular text with these commands:
  M-Tab      Move to column beneath (or at) next interesting charecter.
        `Indents' relative to a previous line.
  Tab      Move to next stop in tab stop list.
  C-c Tab Set tab stops according to context of this line.
        With ARG resets tab stops to default (global) value.
        See also documentation of variable    picture-tab-chars
        which defines "interesting character".  You can manually
        change the tab stop list with command \[edit-tab-stops].
You can manipulate text with these commands:
  C-d      Clear (replace) ARG columns after point without moving.
  C-c C-d Delete char at point - the command normally assigned to C-d.
  Delete  Clear (replace) ARG columns before point, moving back over them.
  C-k      Clear ARG lines, advancing over them.     The cleared
        text is saved in the kill ring.
  C-o      Open blank line(s) beneath current line.
You can manipulate rectangles with these commands:
  C-c C-k Clear (or kill) a rectangle and save it.
  C-c C-w Like C-c C-k except rectangle is saved in named register.
  C-c C-y Overlay (or insert) currently saved rectangle at point.
  C-c C-x Like C-c C-y except rectangle is taken from named register.
  \[copy-rectangle-to-register]   Copies a rectangle to a register.
  \[advertised-undo]   Can undo effects of rectangle overlay commands
        commands if invoked soon enough.
You can return to the previous mode with:
  C-c C-c Which also strips trailing whitespace from every line.
        Stripping is suppressed by supplying an argument.

Entry to this mode calls the value of  edit-picture-hook  if non-nil.

Note that Picture mode commands will work outside of Picture mode, but
they are not defaultly assigned to keys.
Fprolog-mode
Major mode for editing Prolog code for Prologs.
Blank lines and `%%...' separate paragraphs.  `%'s start comments.
Commands:
\{prolog-mode-map}
Entry to this mode calls the value of prolog-mode-hook
if that value is non-nil.
Frun-prolog
Run an inferior Prolog process, input and output via buffer *prolog*.
Fclear-rectangle
Blank out rectangle with corners at point and mark.
The text previously in the region is overwritten by the blanks.
Fdelete-rectangle
Delete (don't save) text in rectangle with point and mark as corners.
The same range of columns is deleted in each line
starting with the line where the region begins
and ending with the line where the region ends.
Fdelete-extract-rectangle
Return and delete contents of rectangle with corners at START and END.
Value is list of strings, one for each line of the rectangle.
Fextract-rectangle
Return contents of rectangle with corners at START and END.
Value is list of strings, one for each line of the rectangle.
Finsert-rectangle
Insert text of RECTANGLE with upper left corner at point.
RECTANGLE's first line is inserted at point,
its second line is inserted at a point vertically under point, etc.
RECTANGLE should be a list of strings.
Fkill-rectangle
Delete rectangle with corners at point and mark; save as last killed one.
Calling from program, supply two args START and END, buffer positions.
But in programs you might prefer to use delete-extract-rectangle.
Fopen-rectangle
Blank out rectangle with corners at point and mark, shifting text right.
The text previously in the region is not overwritten by the blanks,
but insted winds up to the right of the rectangle.
Fyank-rectangle
Yank the last killed rectangle with upper left corner at point.
Frnews
Read USENET news for groups for which you are a member and add or
delete groups.
You can reply to articles posted and send articles to any group.

Type \[describe-mode] once reading news to get a list of rnews commands.
Fnews-post-news
Begin editing a new USENET news article to be posted.
Type \[describe-mode] once editing the article to get a list of commands.
Frmail
Read and edit incoming mail.
Moves messages into file named by  rmail-file-name  (a babyl format file)
 and edits that file in RMAIL Mode.
Type \[describe-mode] once editing that file, for a list of RMAIL commands.

May be called with filename as argument;
then performs rmail editing on that file,
but does not copy any new mail into the file.
Frmail-input
Run RMAIL on file FILENAME.
Vrmail-dont-reply-to-names
*A regular expression specifying names to prune in replying to messages.
nil means don't reply to yourself.
Vrmail-default-dont-reply-to-names
A regular expression specifying part of the value of the default value of
the variable `rmail-dont-reply-to-names', for when the user does not set
`rmail-dont-reply-to-names' explicitly.  (The other part of the default
value is the user's name.)
It is useful to set this variable in the site customisation file.
Vrmail-primary-inbox-list
*List of files which are inboxes for user's primary mail file ~/RMAIL.
`nil' means the default, which is ("/usr/spool/mail/$USER" "~/mbox")
(the first name varies depending on the operating system,
and the value of the environment variable MAIL overrides it).
Vrmail-ignored-headers
*Gubbish header fields one would rather not see.
Vrmail-delete-after-output
*Non-nil means automatically delete a message that is copied to a file.
Fstart-timer
Start a timer.
Args are NAME, FUNCTION, VALUE &optional RESTART.
NAME is an identifier for the timer.  It must be a string.  If a timer
  already exists with this name, NAME will be modified slightly to until
  it is unique.
FUNCTION should be a function (or symbol naming one) of no arguments.  It
  will be called each time the timer expires.  The function can access
  timer that invoked it through the variable `current-timer'.
VALUE is the number of seconds until this timer expires.
Optional fourth arg RESTART non-nil means that this timer should be
  restarted automatically after its function is called.  Normally a timer
  is deleted at expiration after its function has returned.
  If non-nil RESTART should be a number indicating the value at which the
  timer should be set at restart time.
Returns the newly created timer.
Vauto-save-timeout
*Number of seconds idle time before auto-save.
Zero or nil means disable auto-saving due to idleness.

The actual amount of idle time between auto-saves is logarithmically related
to the size of the current buffer.  This variable is the number of seconds
after which an auto-save will happen when the current buffer is 50k or less;
the timeout will be 2 1/4 times this in a 200k buffer, 3 3/4 times this in a
1000k buffer, and 4 1/2 times this in a 2000k buffer.

For this variable to have any effect, you must do (require 'timer).

See also the variable `auto-save-interval', which controls auto-saving based
on the number of characters typed.
Frun-scheme
Run an inferior Scheme process.
Output goes to the buffer `*scheme*'.
With argument, asks for a command line.
Fscheme-mode
Major mode for editing Scheme code.
Editing commands are similar to those of lisp-mode.

In addition, if an inferior Scheme process is running, some additional
commands will be defined, for evaluating expressions and controlling
the interpreter, and the state of the process will be displayed in the
modeline of all Scheme buffers.  The names of commands that interact
with the Scheme process start with "xscheme-".  For more information
see the documentation for xscheme-interaction-mode.

Commands:
Delete converts tabs to spaces as it moves back.
Blank lines separate paragraphs.  Semicolons start comments.
\{scheme-mode-map}
Entry to this mode calls the value of scheme-mode-hook
if that value is non-nil.
Fscribe-mode
Major mode for editing files of Scribe (a text formatter) source.
Scribe-mode is similar text-mode, with a few extra commands added.
\{scribe-mode-map}

Interesting variables:

scribe-fancy-paragraphs
  Non-nil makes Scribe mode use a different style of paragraph separation.

scribe-electric-quote
  Non-nil makes insert of double quote use `` or '' depending on context.

scribe-electric-parenthesis
  Non-nil makes an open-parenthesis char (one of `([<{')
  automatically insert its close if typed after an @Command form.
Vsend-mail-function
Function to call to send the current buffer as mail.
The headers are delimited by a string found in mail-header-separator.
Vmail-self-blind
*Non-nil means insert BCC to self in messages to be sent.
This is done when the message is initialized,
so you can remove or alter the BCC field to override the default.
Vmail-interactive
*Non-nil means when sending a message wait for and display errors.
nil means let mailer mail back a message to report errors.
Vmail-yank-ignored-headers
Delete these headers from old message when it's inserted in a reply.
Vmail-header-separator
*Line used to separate headers from text in messages being composed.
Vmail-archive-file-name
*Name of file to write all outgoing messages in, or nil for none.
Do not use an rmail file here!  Instead, use its inbox file.
Vmail-signature-file
File to be inserted at the end of a message. Usually, this file is called
"~/.signature".
Vmail-aliases
Word-abbrev table of mail address aliases.
If this is nil, it means the aliases have not yet been initialized and
should be read from the .mailrc file.  (This is distinct from there being
no aliases, which is represented by this being a table with no entries.)
Vmail-abbrev-mailrc-file
Name of file with mail aliases.   If nil, ~/.mailrc is used.
Fmail-other-window
Like `mail' command, but display mail buffer in another window.
Fmail
Edit a message to be sent.  Argument means resume editing (don't erase).
Returns with message buffer selected; value t if message freshly initialized.
While editing message, type C-c C-c to send the message and exit.

Various special commands starting with C-c are available in sendmail mode
to move to message header fields:
\{mail-mode-map}

If mail-self-blind is non-nil, a BCC to yourself is inserted
when the message is initialized.

If mail-default-reply-to is non-nil, it should be an address (a string);
a Reply-to: field with that address is inserted.

If mail-archive-file-name is non-nil, an FCC field with that file name
is inserted.

If mail-setup-hook is bound, its value is called with no arguments
after the message is initialized.  It can add more default fields.

When calling from a program, the second through fifth arguments
 TO, SUBJECT, IN-REPLY-TO and CC specify if non-nil
 the initial contents of those header fields.
 These arguments should not have final newlines.
The sixth argument REPLYBUFFER is a buffer whose contents
 should be yanked if the user types C-c C-y.
Fmail-mode
Major mode for editing mail to be sent.
Like Text Mode but with these additional commands:
C-c C-s  mail-send (send the message)    C-c C-c  mail-send-and-exit
C-c C-f  move to a header field (and create it if there isn't):
     C-c C-f C-t  move to To:    C-c C-f C-s  move to Subj:
     C-c C-f C-b  move to BCC:    C-c C-f C-c  move to CC:
C-c C-t  move to message text.
C-c C-w  mail-signature (insert ~/.signature at end).
C-c C-y  mail-yank-original (insert current message, in Rmail).
C-c C-q  mail-fill-yanked-message (fill what was yanked).
Vmail-use-rfc822
*If non-nil, use a full, hairy RFC822 parser on mail addresses.
Otherwise, (the default) use a smaller, somewhat faster and
often-correct parser.
Ffeedmail-send-it
Replacement for sendmail-send-it.  Do this to use it:
(setq send-mail-function 'feedmail-send-it)
Fserver-start
Allow this Emacs process to be a server for client processes.
This starts a server communications subprocess through which
client "editors" can send your editing commands to this Emacs job.
To use the server, set up the program `etc/emacsclient' in the
Emacs distribution as your standard "editor".

Prefix arg means just kill any existing server communications subprocess.
Frun-lisp
Run an inferior Lisp process, input and output via buffer *lisp*.
Fshell
Run an inferior shell, with I/O through buffer *shell*.
If buffer exists but shell process is not running, make new shell.
Program used comes from variable explicit-shell-file-name,
 or (if that is nil) from the ESHELL environment variable,
 or else from SHELL if there is no ESHELL.
If a file ~/.emacs_SHELLNAME exists, it is given as initial input
 (Note that this may lose due to a timing error if the shell
  discards input when it starts up.)
The buffer is put in shell-mode, giving commands for sending input
and controlling the subjobs of the shell.  See shell-mode.
See also variable shell-prompt-pattern.

The shell file name (sans directories) is used to make a symbol name
such as `explicit-csh-arguments'.  If that symbol is a variable,
its value is used as a list of arguments when invoking the shell.
Otherwise, one argument `-i' is passed to the shell.

Note that many people's .cshrc files unconditionally clear the prompt.
If yours does, you will probably want to change it.
Fcomint-dynamic-complete
Dynamically complete the filename at point.
This function is similar to comint-replace-by-expanded-filename, except
that it won't change parts of the filename already entered in the buffer;
it just adds completion characters to the end of the filename.
Fcomint-dynamic-list-completions
List in help buffer all possible completions of the filename at point.
Fsort-lines
Sort lines in region alphabetically; argument means descending order.
Called from a program, there are three arguments:
REVERSE (non-nil means reverse order), BEG and END (region to sort).
Fsort-paragraphs
Sort paragraphs in region alphabetically; argument means descending order.
Called from a program, there are three arguments:
REVERSE (non-nil means reverse order), BEG and END (region to sort).
Fsort-pages
Sort pages in region alphabetically; argument means descending order.
Called from a program, there are three arguments:
REVERSE (non-nil means reverse order), BEG and END (region to sort).
Fsort-numeric-fields
Sort lines in region numerically by the ARGth field of each line.
Fields are separated by whitespace and numbered from 1 up.
Specified field must contain a number in each line of the region.
With a negative arg, sorts by the -ARG'th field, in reverse order.
Called from a program, there are three arguments:
FIELD, BEG and END.  BEG and END specify region to sort.
Fsort-fields
Sort lines in region lexicographically by the ARGth field of each line.
Fields are separated by whitespace and numbered from 1 up.
With a negative arg, sorts by the -ARG'th field, in reverse order.
Called from a program, there are three arguments:
FIELD, BEG and END.  BEG and END specify region to sort.
Fsort-columns
Sort lines in region alphabetically by a certain range of columns.
For the purpose of this command, the region includes
the entire line that point is in and the entire line the mark is in.
The column positions of point and mark bound the range of columns to sort on.
A prefix argument means sort into reverse order.

Note that sort-columns uses the sort utility program and therefore
cannot work on text containing TAB characters.  Use M-x untabify
to convert tabs to spaces before sorting.
Fsort-regexp-fields
Sort the region lexicographically as specifed by RECORD-REGEXP and KEY.
RECORD-REGEXP specifies the textual units which should be sorted.
  For example, to sort lines RECORD-REGEXP would be "^.*$"
KEY specifies the part of each record (ie each match for RECORD-REGEXP)
  is to be used for sorting.
  If it is "\digit" then the digit'th "\(...\)" match field from
  RECORD-REGEXP is used.
  If it is "\&" then the whole record is used.
  Otherwise, it is a regular-expression for which to search within the record.
If a match for KEY is not found within a record then that record is ignored.

With a negative prefix arg sorts in reverse order.

For example: to sort lines in the region by the first word on each line
 starting with the letter "f",
 RECORD-REGEXP would be "^.*$" and KEY would be "\=\<f\w*\>"
Fspell-buffer
Check spelling of every word in the buffer.
For each incorrect word, you are asked for the correct spelling
and then put into a query-replace to fix some or all occurrences.
If you do not want to change a word, just give the same word
as its "correct" spelling; then the query replace is skipped.
Fspell-region
Like spell-buffer but applies only to region.
From program, applies from START to END.
Fspell-word
Check spelling of word at or before point.
If it is not correct, ask user for the correct spelling
and query-replace the entire buffer to substitute it.
Fspell-string
Check spelling of string supplied as argument.
Funtabify
Convert all tabs in region to multiple spaces, preserving columns.
The variable tab-width controls the action.
Ftabify
Convert multiple spaces in region to tabs when possible.
A group of spaces is partially replaced by tabs
when this can be done without changing the column they end at.
The variable tab-width controls the action.
Ffind-tag
*Find tag whose name contains TAGNAME.
Selects the buffer that the tag is contained in and puts
 point at its definition.
If TAGNAME is a null string, the expression in the buffer
 around or before point is used as the tag name.
If second arg NEXT is non-nil (interactively, with prefix arg),
 searches for the next tag in the tag table that matches the
 tagname used in the previous find-tag.

Multiple active tags tables and completion are supported.

Variables of note:

  tag-table-alist        controls which tables apply to which buffers
  tags-file-name        a default tags table
  tags-build-completion-table   controls completion behavior
  buffer-tag-table        another way of specifying a buffer-local table
  make-tags-files-invisible    whether tags tables should be very hidden
  tag-mark-stack-max        how many tags-based hops to remember
Ffind-tag-other-window
*Find tag whose name contains TAGNAME.
Selects the buffer that the tag is contained in in another window
 and puts point at its definition.
If TAGNAME is a null string, the expression in the buffer
 around or before point is used as the tag name.
If second arg NEXT is non-nil (interactively, with prefix arg),
 searches for the next tag in the tag table that matches the
 tagname used in the previous find-tag.

Multiple active tags tables and completion are supported.

Variables of note:

  tag-table-alist        controls which tables apply to which buffers
  tags-file-name        a default tags table
  tags-build-completion-table   controls completion behavior
  buffer-tag-table        another way of specifying a buffer-local table
  make-tags-files-invisible    whether tags tables should be very hidden
  tag-mark-stack-max        how many tags-based hops to remember
Flist-tags
Display list of tags in file FILE.
FILE should not contain a directory spec
unless it has one in the tag table.
Fnext-file
Select next file among files in current tag table(s).
Non-nil argument (prefix arg, if interactive)
initializes to the beginning of the list of files in the (first) tag table.
Ftags-apropos
Display list of all tags in tag table REGEXP matches.
Ftags-loop-continue
Continue last \[tags-search] or \[tags-query-replace] command.
Used noninteractively with non-nil argument
to begin such a command.  See variable tags-loop-form.
Ftag-table-files
Returns a list of the files referenced by the named TAGS table.
Ftags-query-replace
Query-replace-regexp FROM with TO through all files listed in tag table.
Third arg DELIMITED (prefix arg) means replace only word-delimited matches.
If you exit (C-G or ESC), you can resume the query-replace
with the command \[tags-loop-continue].

See documentation of variable tag-table-alist.
Ftags-search
Search through all files listed in tag table for match for REGEXP.
Stops when a match is found.
To continue searching for next match, use command \[tags-loop-continue].

See documentation of variable tag-table-alist.
Fvisit-tags-table
Tell tags commands to use tags table file FILE first.
FILE should be the name of a file created with the `etags' program.
A directory name is ok too; it means file TAGS in that directory.
This function is largely obsoleted by the variable tag-table-alist.
Ftelnet
Open a network login connection to host named HOST (a string).
Communication with HOST is recorded in a buffer *HOST-telnet*.
Normally input is edited in Emacs and sent a line at a time.
See also `\[rsh]'.
Frsh
Open a network login connection to host named HOST (a string).
Communication with HOST is recorded in a buffer *HOST-rsh*.
Normally input is edited in Emacs and sent a line at a time.
See also `\[telnet]'.
Fterminal-emulator
Under a display-terminal emulator in BUFFER, run PROGRAM on arguments ARGS.
ARGS is a list of argument-strings.  Remaining arguments are WIDTH and HEIGHT.
BUFFER's contents are made an image of the display generated by that program,
and any input typed when BUFFER is the current Emacs buffer is sent to that
program an keyboard input.

Interactively, BUFFER defaults to "*terminal*" and PROGRAM and ARGS
are parsed from an input-string using your usual shell.
WIDTH and HEIGHT are determined from the size of the current window
-- WIDTH will be one less than the window's width, HEIGHT will be its height.

To switch buffers and leave the emulator, or to give commands
to the emulator itself (as opposed to the program running under it),
type Control-^.  The following character is an emulator command.
Type Control-^ twice to send it to the subprogram.
This escape character may be changed using the variable `terminal-escape-char'.

`Meta' characters may not currently be sent through the terminal emulator.

Here is a list of some of the variables which control the behaviour
of the emulator -- see their documentation for more information:
terminal-escape-char, terminal-scrolling, terminal-more-processing,
terminal-redisplay-interval.

This function calls the value of terminal-mode-hook if that exists
and is non-nil after the terminal buffer has been set up and the
subprocess started.

Presently with `termcap' only; if somebody sends us code to make this
work with `terminfo' we will try to use it.
Flatex-mode
Major mode for editing files of input for LaTeX.
Makes $ and } display the characters they match.
Makes " insert `` when it seems to be the beginning of a quotation,
and '' when it appears to be the end; it inserts " only after a \.

Use \[TeX-region] to run LaTeX on the current region, plus the preamble
copied from the top of the file (containing \documentstyle, etc.),
running LaTeX under a special subshell.  \[TeX-buffer] does the whole buffer.
\[TeX-print] prints the .dvi file made by either of these.

Use \[validate-TeX-buffer] to check buffer for paragraphs containing
mismatched $'s or braces.

Special commands:
\{TeX-mode-map}

Mode variables:
TeX-directory
    Directory in which to create temporary files for TeX jobs
    run by \[TeX-region] or \[TeX-buffer].
TeX-dvi-print-command
    Command string used by \[TeX-print] to print a .dvi file.
TeX-show-queue-command
    Command string used by \[TeX-show-print-queue] to show the print
    queue that \[TeX-print] put your job on.

Entering LaTeX mode calls the value of text-mode-hook,
then the value of TeX-mode-hook, and then the value
of LaTeX-mode-hook.
Fplain-tex-mode
Major mode for editing files of input for plain TeX.
Makes $ and } display the characters they match.
Makes " insert `` when it seems to be the beginning of a quotation,
and '' when it appears to be the end; it inserts " only after a \.

Use \[TeX-region] to run TeX on the current region, plus a "header"
copied from the top of the file (containing macro definitions, etc.),
running TeX under a special subshell.  \[TeX-buffer] does the whole buffer.
\[TeX-print] prints the .dvi file made by either of these.

Use \[validate-TeX-buffer] to check buffer for paragraphs containing
mismatched $'s or braces.

Special commands:
\{TeX-mode-map}

Mode variables:
TeX-directory
    Directory in which to create temporary files for TeX jobs
    run by \[TeX-region] or \[TeX-buffer].
TeX-dvi-print-command
    Command string used by \[TeX-print] to print a .dvi file.
TeX-show-queue-command
    Command string used by \[TeX-show-print-queue] to show the print
    queue that \[TeX-print] put your job on.

Entering plain-TeX mode calls the value of text-mode-hook,
then the value of TeX-mode-hook, and then the value
of plain-TeX-mode-hook.
Ftex-mode
Major mode for editing files of input for TeX or LaTeX.
Trys to intuit whether this file is for plain TeX or LaTeX and
calls plain-tex-mode or latex-mode.  If it cannot be determined
(e.g., there are no commands in the file), the value of
TeX-default-mode is used.
Ftexinfo-mode
Major mode for editing texinfo files.
These are files that are input for TEX and also to be turned
into Info files by \[texinfo-format-buffer].
These files must be written in a very restricted and
modified version of TEX input format.

As for editing commands, like text-mode except for syntax table,
which is set up so expression commands skip texinfo bracket groups.
Ftexinfo-format-buffer
Process the current buffer as texinfo code, into an Info file.
The Info file output is generated in a buffer
visiting the Info file names specified in the @setfilename command.

Non-nil argument (prefix, if interactive) means don't make tag table
and don't split the file if large.  You can use Info-tagify and
Info-split to do these manually.
Ftexinfo-format-region
Convert the the current region of the Texinfo file to Info format.
This lets you see what that part of the file will look like in Info.
The command is bound to \[texinfo-format-region].  The text that is
converted to Info is stored in a temporary buffer.
Fbatch-texinfo-format
Runs  texinfo-format-buffer  on the files remaining on the command line.
Must be used only with -batch, and kills emacs on completion.
Each file will be processed even if an error occurred previously.
For example, invoke
  "emacs -batch -funcall batch-texinfo-format $docs/ ~/*.texinfo".
Fdisplay-time
Display current time and load level in mode line of each buffer.
Updates automatically every minute.
If display-time-day-and-date is non-nil, the current day and date
are displayed as well.
Funderline-region
Underline all nonblank characters in the region.
Works by overstriking underscores.
Called from program, takes two arguments START and END
which specify the range to operate on.
Fununderline-region
Remove all underlining (overstruck underscores) in the region.
Called from program, takes two arguments START and END
which specify the range to operate on.
Fask-user-about-lock
Ask user what to do when he wants to edit FILE but it is locked by USER.
This function has a choice of three things to do:
  do (signal 'buffer-file-locked (list FILE USER))
    to refrain from editing the file
  return t (grab the lock on the file)
  return nil (edit the file even though it is locked).
You can rewrite it to use any criterion you like to choose which one to do.
Fask-user-about-supersession-threat
Ask a user who is about to modify an obsolete buffer what to do.
This function has two choices: it can return, in which case the modification
of the buffer will proceed, or it can (signal 'file-supersession (file)),
in which case the proposed buffer modification will not be made.

You can rewrite this to use any criterion you like to choose which one to do.
The buffer in question is current when this function is called.
Fvi-mode
Major mode that acts like the `vi' editor.
The purpose of this mode is to provide you the combined power of vi (namely,
the "cross product" effect of commands and repeat last changes) and Emacs.

This command redefines nearly all keys to look like vi commands.
It records the previous major mode, and any vi command for input
(`i', `a', `s', etc.) switches back to that mode.
Thus, ordinary Emacs (in whatever major mode you had been using)
is "input" mode as far as vi is concerned.

To get back into vi from "input" mode, you must issue this command again.
Therefore, it is recommended that you assign it to a key.

Major differences between this mode and real vi :

* Limitations and unsupported features
  - Search patterns with line offset (e.g. /pat/+3 or /pat/z.) are
    not supported.
  - Ex commands are not implemented; try ':' to get some hints.
  - No line undo (i.e. the 'U' command), but multi-undo is a standard feature.

* Modifications
  - The stopping positions for some point motion commands (word boundary,
    pattern search) are slightly different from standard 'vi'.
    Also, no automatic wrap around at end of buffer for pattern searching.
  - Since changes are done in two steps (deletion then insertion), you need
    to undo twice to completely undo a change command.  But this is not needed
    for undoing a repeated change command.
  - No need to set/unset 'magic', to search for a string with regular expr
    in it just put a prefix arg for the search commands.  Replace cmds too.
  - ^R is bound to incremental backward search, so use ^L to redraw screen.

* Extensions
  - Some standard (or modified) Emacs commands were integrated, such as
    incremental search, query replace, transpose objects, and keyboard macros.
  - In command state, ^X links to the 'ctl-x-map', and ESC can be linked to
    esc-map or set undefined.  These can give you the full power of Emacs.
  - See vi-com-map for those keys that are extensions to standard vi, e.g.
    `vi-name-last-change-or-macro', `vi-verify-spelling', `vi-locate-def',
    `vi-mark-region', and 'vi-quote-words'.  Some of them are quite handy.
  - Use \[vi-switch-mode] to switch among different modes quickly.

Syntax table and abbrevs while in vi mode remain as they were in Emacs.
Fview-file
Find FILE, enter view mode.  With prefix arg use other window.
Fview-buffer
Switch to BUF, enter view mode.  With prefix arg use other window.
Fview-mode
Mode for viewing text, with bindings like `less'.
Fvip-mode
Begin emulating the vi editor.  This is distinct from `vi-mode'.
This emulator has different capabilities from the `vi-mode' emulator.
See the text at the beginning of the source file .../lisp/vip.el
in the Emacs distribution.
Fevi
Start vi emulation in this buffer.  Of all the those available, this
emulator most closely resembles vi.
See the text at the beginning of the source file .../lisp/evi.el
in the Emacs distribution.
Fyow
Return or display a Zippy quotation
Fpsychoanalyze-pinhead
Zippy goes to the analyst.
Fquery-replace
Replace some occurrences of FROM-STRING with TO-STRING.
As each match is found, the user must type a character saying
what to do with it.  For directions, type \[help-command] at that time.

Preserves case in each replacement if  case-replace  and  case-fold-search
are non-nil and FROM-STRING has no uppercase letters.
Third arg DELIMITED (prefix arg if interactive) non-nil means replace
only matches surrounded by word boundaries.
Fquery-replace-regexp
Replace some things after point matching REGEXP with TO-STRING.
As each match is found, the user must type a character saying
what to do with it.  For directions, type \[help-command] at that time.

Preserves case in each replacement if  case-replace  and  case-fold-search
are non-nil and REGEXP has no uppercase letters.
Third arg DELIMITED (prefix arg if interactive) non-nil means replace
only matches surrounded by word boundaries.
In TO-STRING, \& means insert what matched REGEXP,
and \=\<n> means insert what matched <n>th \(...\) in REGEXP.
Fmap-query-replace-regexp
Replace some matches for REGEXP with various strings, in rotation.
The second argument TO-STRINGS contains the replacement strings, separated
by spaces.  This command works like `query-replace-regexp' except
that each successive replacement uses the next successive replacement string,
wrapping around from the last such string to the first.

Non-interactively, TO-STRINGS may be a list of replacement strings.

A prefix argument N says to use each replacement string N times
before rotating to the next.
Freplace-string
Replace occurrences of FROM-STRING with TO-STRING.
Preserve case in each match if `case-replace' and `case-fold-search'
are non-nil and FROM-STRING has no uppercase letters.
Third arg DELIMITED (prefix arg if interactive) non-nil means replace
only matches surrounded by word boundaries.

This function is usually the wrong thing to use in a Lisp program.
What you probably want is a loop like this:
  (while (search-forward OLD-STRING nil t)
    (replace-match REPLACEMENT nil t))
which will run faster and will not set the mark or print anything.
Freplace-regexp
Replace things after point matching REGEXP with TO-STRING.
Preserve case in each match if case-replace and case-fold-search
are non-nil and REGEXP has no uppercase letters.
Third arg DELIMITED (prefix arg if interactive) non-nil means replace
only matches surrounded by word boundaries.
In TO-STRING, \& means insert what matched REGEXP,
and \=\<n> means insert what matched <n>th \(...\) in REGEXP.

This function is usually the wrong thing to use in a Lisp program.
What you probably want is a loop like this:
  (while (re-search-forward REGEXP nil t)
    (replace-match REPLACEMENT nil nil))
which will run faster and will not set the mark or print anything.
Fload-sound-file
Read in an audio-file and add it to the sound-alist.
Fload-default-sounds
Load and install some sound files as beep-types.
This only works if you're on display 0 of a Sun SparcStation.
Fvm
View Mail: an alternate mail reader for emacs.
Optional first arg FOLDER specifies the folder to visit.  It defaults
to the value of vm-primary-inbox.  The folder buffer is put into VM
mode, a major mode for reading mail.

Prefix arg or optional second arg READ-ONLY non-nil indicates
that the folder should be considered read only.  No attribute
changes, messages additions or deletions will be allowed in the
visited folder.

Visiting the primary inbox causes any contents of the system mailbox to
be moved and appended to the resulting buffer.

All the messages can be read by repeatedly pressing SPC.  Use `n'ext and
`p'revious to move about in the folder.  Messages are marked for
deletion with `d', and saved to another folder with `s'.  Quitting VM
with `q' expunges deleted messages and saves the buffered folder to
disk.

See the documentation for vm-mode for more information.
Fvm-mode
View Mail: an alternate mail reader for emacs.

Commands:
   h - summarize folder contents
   j - discard cached information about the current message

   n - go to next message
   p - go to previous message
   N - like `n' but ignores skip-variable settings
   P - like `p' but ignores skip-variable settings
 M-n - go to next unread message
 M-p - go to previous unread message
 RET - go to numbered message (uses prefix arg or prompts in minibuffer)
 TAB - go to last message seen
 M-s - incremental search through the folder

   t - display hidden headers
 SPC - scroll forward a page (if at end of message, then display next message)
   b - scroll backward a page
   < - go to beginning of current message
   > - go to end of current message

   d - delete message, prefix arg deletes messages forward (flag as deleted)
 C-d - delete message, prefix arg deletes messages backward (flag as deleted)
   u - undelete
   k - flag for deletion all messages with same subject as the current message

   r - reply (only to the sender of the message)
   R - reply with included text for current message
 M-r - extract and resend bounced message
   f - followup (reply to all recipients of message)
   F - followup with included text from the current message
   z - forward the current message
   m - send a message
   B - resend the current message to another user.
   c - continue composing the most recent message you were composing

   @ - digestify and mail entire folder contents (the folder is not modified)
   * - burst a digest into individual messages, and append and assimilate these
       message into the current folder.

   G - group messages according to some criteria

   g - get any new mail that has arrived in the system mailbox
       (new mail is appended to the disk and buffer copies of the
       primary inbox.)
   v - visit another mail folder
   V - visit a virtual folder

   e - edit the current message

   s - save current message in a folder (appends if folder already exists)
   w - write current message to a file without its headers (appends if exists)
   S - save entire folder to disk, expunging deleted messages
   A - save unfiled messages to their vm-auto-folder-alist specified folders
   # - expunge deleted messages (without saving folder)
   q - quit VM, deleted messages are expunged, folder saved to disk
   x - exit VM with no change to the folder

 M N - use marks; the next vm command will affect only marked messages
       if it makes sense for the command to do so

       M m - mark the current message
       M u - unmark the current message
       M M - mark all messsages
       M U - unmark all messsages

 C-_ - undo, special undo that retracts the most recent
             changes in message attributes.  Expunges and saves
             cannot be undone.  C-x u is also bound to this
             command.

   L - reload your VM init file, ~/.vm

   ? - help

   ! - run a shell command
   | - run a shell command with the current message as input

 M-C - view conditions under which you may redistribute VM
 M-W - view the details of VM's lack of a warranty

Variables:
   vm-auto-center-summary
   vm-auto-folder-alist
   vm-auto-folder-case-fold-search
   vm-auto-next-message
   vm-berkeley-mail-compatibility
   vm-circular-folders
   vm-confirm-new-folders
   vm-confirm-quit
   vm-crash-box
   vm-delete-after-archiving
   vm-delete-after-bursting
   vm-delete-after-saving
   vm-delete-empty-folders
   vm-digest-center-preamble
   vm-digest-preamble-format
   vm-folder-directory
   vm-folder-read-only
   vm-follow-summary-cursor
   vm-forwarding-subject-format
   vm-gargle-uucp
   vm-group-by
   vm-highlighted-header-regexp
   vm-honor-page-delimiters
   vm-in-reply-to-format
   vm-included-text-attribution-format
   vm-included-text-prefix
   vm-inhibit-startup-message
   vm-invisible-header-regexp
   vm-keep-sent-messages
   vm-mail-window-percentage
   vm-mode-hooks
   vm-move-after-deleting
   vm-move-after-undeleting
   vm-mutable-windows
   vm-preview-lines
   vm-preview-read-messages
   vm-primary-inbox
   vm-retain-message-order
   vm-reply-ignored-addresses
   vm-reply-subject-prefix
   vm-rfc934-forwarding
   vm-search-using-regexps
   vm-skip-deleted-messages
   vm-skip-read-messages
   vm-spool-files
   vm-startup-with-summary
   vm-strip-reply-headers
   vm-summary-format
   vm-virtual-folder-alist
   vm-virtual-mirror
   vm-visible-headers
   vm-visit-when-saving
Fvm-visit-folder
Visit a mail file with View Mail, an alternate mail reader for emacs.
See the description of the `vm' and `vm-mode' functions.

VM will parse and present its messages to you in the usual way.

First arg FOLDER specifies the mail file to visit.  When this
command is called interactively the file name is read from the
minibuffer.

Prefix arg or optional second arg READ-ONLY non-nil indicates
that the folder should be considered read only.  No attribute
changes, messages additions or deletions will be allowed in the
visited folder.
Fvm-mail
Send a mail message from within View Mail, or from without.
Fwebster
Look up a word in Webster's 7th edition
Fwebster-spell
Search for an approximately-spelled word in Webster's 7th edition
Fwebster-endings
Search for a word in Webster's 7th edition that begins with a certain prefix
Fpostscript-mode
Major mode for editing PostScript programs.
Fgnus
Read network news.
Fgnus-post-news
Post a netnews article.
Ftar-mode
Major mode for editing `tar' (tape archive) files in a dired-like manner.
Fconx
Generate some random sentences in the *conx* buffer.
Output will be continuously generated until you type ^G.
Before running this function, you must snarf some text into the CONX
database with the M-x conx-buffer or M-x conx-region commands.
Fconx-load
Load a CONX database that has been previously saved with M-x conx-save.
Fconx-buffer
Absorb the text in the current buffer into the CONX database;
use the M-x conx command to generate random sentences based on the
word frequency in this buffer.  Multiple uses of this function are
additive; to clear the database and start over, use M-x conx-init.
Fconx-region
Absorb the text in the current buffer into the CONX database;
use the M-x conx command to generate random sentences based on the
word frequency in this region.  Multiple uses of this function are
additive; to clear the database and start over, use M-x conx-init.
Fwith-timeout
Usage: (with-timeout (seconds &rest timeout-forms) &rest body)
This is just like progn, but if the given number of seconds expires before
the body returns, then timeout-forms are evaluated and returned instead.
The body won't be interrupted in the middle of a computation: the check for
the timer expiration only occurs when body does a redisplay, or prompts the
user for input, or calls accept-process-output.
Fyes-or-no-p-with-timeout
Just like yes-or-no-p, but will time out after TIMEOUT seconds
if the user has not yes answered, returning DEFAULT-VALUE.
Fy-or-n-p-with-timeout
Just like y-or-n-p, but will time out after TIMEOUT seconds
if the user has not yes answered, returning DEFAULT-VALUE.
Fhighlight-headers
Highlight message headers between start and end.
Faces used:
  message-headers            the part before the colon
  message-header-contents        the part after the colon
  message-highlighted-header-contents    contents of "special" headers
  message-cited-text            quoted text from other messages

Variables used:

  highlight-headers-regexp            what makes a "special" header
  highlight-headers-citation-regexp        matches lines of quoted text
  highlight-headers-citation-header-regexp    matches headers for quoted text

If HACK-SIG is true,then we search backward from END for something that
looks like the beginning of a signature block, and don't consider that a
part of the message (this is because signatures are often incorrectly
interpreted as cited text.)
Frun-ilisp
Select a new inferior LISP.
Fclisp
Run an inferior generic Common LISP.
Fallegro
Run an inferior Allegro Common LISP.
Flucid
Run an inferior Lucid Common LISP.
Fcmulisp
Run an inferior CMU Common LISP.
Fkcl
Run an inferior Kyoto Common LISP.
Fscheme
Run an inferior generic Scheme.
Foaklisp
Run an inferior Oaklisp Scheme.
Fhexl-find-file
Edit file FILENAME in hexl-mode.
Fread-passwd
Prompts for a password in the minibuffer, and returns it as a string.
If PROMPT may be a prompt string or an alist of elements
'(prompt . default).
If optional arg CONFIRM is true, then ask the user to type the password
again to confirm that they typed it correctly.
If optional arg DEFAULT is provided, then it is a string to insert as
the default choice (it is not, of course, displayed.)

If running under X, the keyboard will be grabbed (with XGrabKeyboard())
to reduce the possibility that evesdropping is occuring.

When reading a password, all keys self-insert, except for:
\<read-passwd-map>
    \[read-passwd-erase-line]    Erase the entire line.
    \[quoted-insert]    Insert the next character literally.
    \[delete-backward-char]    Delete the previous character.
    \[exit-minibuffer]    Accept what you have typed.
    \[keyboard-quit]    Abort the command.

The returned value is always a newly-created string.  No additional copies
of the password remain after this function has returned.

NOTE: unless great care is taken, the typed password will exist in plaintext
form in the running image for an arbitrarily long time.  Priveleged users may
be able to extract it from memory.  If emacs crashes, it may appear in the
resultant core file.

Some steps you can take to prevent the password from being copied around:

 - as soon as you are done with the returned string, destroy it with
   (fillarray string 0).  The same goes for any default passwords
   or password histories.

 - do not copy the string, as with concat or substring - if you do, be
   sure to keep track of and destroy all copies.

 - do not insert the password into a buffer - if you do, be sure to
   overwrite the buffer text before killing it, as with the functions
   `passwd-erase-buffer' or `passwd-kill-buffer'.  Note that deleting
   the text from the buffer does NOT necessarily remove the text from
   memory.

 - be careful of the undo history - if you insert the password into a
   buffer which has undo recording turned on, the password will be
   copied onto the undo list, and thus recoverable.

 - do not pass it as an argument to a shell command - anyone will be
   able to see it if they run `ps' at the right time.

Note that the password will be temporarily recoverable with the `view-lossage'
command.  This data will not be overwritten until another hundred or so
characters are typed.  There's not currently a way around this.
Fperl-mode
Major mode for editing Perl code.
Expression and list commands understand all Perl brackets.
Tab indents for Perl code.
Comments are delimited with # ... \n.
Paragraphs are separated by blank lines only.
Delete converts tabs to spaces as it moves back.
\{perl-mode-map}
Variables controlling indentation style:
 perl-tab-always-indent
    Non-nil means TAB in Perl mode should always indent the current line,
    regardless of where in the line point is when the TAB command is used.
 perl-tab-to-comment
    Non-nil means that for lines which don't need indenting, TAB will
    either delete an empty comment, indent an existing comment, move
    to end-of-line, or if at end-of-line already, create a new comment.
 perl-nochange
    Lines starting with this regular expression will not be auto-indented.
 perl-indent-level
    Indentation of Perl statements within surrounding block.
    The surrounding block's indentation is the indentation
    of the line on which the open-brace appears.
 perl-continued-statement-offset
    Extra indentation given to a substatement, such as the
    then-clause of an if or body of a while.
 perl-continued-brace-offset
    Extra indentation given to a brace that starts a substatement.
    This is in addition to perl-continued-statement-offset.
 perl-brace-offset
    Extra indentation for line if it starts with an open brace.
 perl-brace-imaginary-offset
    An open brace following other text is treated as if it were
    this far to the right of the start of its line.
 perl-label-offset
    Extra indentation for line that is a label.

Various indentation styles:       K&R  BSD  BLK  GNU  LW
  perl-indent-level                5    8    0    2    4
  perl-continued-statement-offset  5    8    4    2    4
  perl-continued-brace-offset      0    0    0    0   -4
  perl-brace-offset               -5   -8    0    0    0
  perl-brace-imaginary-offset      0    0    4    0    0
  perl-label-offset               -5   -8   -2   -2   -2

Turning on Perl mode calls the value of the variable perl-mode-hook with no
args, if that value is non-nil.
Furl-file-attributes
Return a list of attributes of URL.
Value is nil if specified file cannot be opened.
Otherwise, list elements are:
 0. t for directory, string (name linked to) for symbolic link, or nil.
 1. Number of links to file.
 2. File uid.
 3. File gid.
 4. Last access time, as a list of two integers.
  First integer has high-order 16 bits of time, second has low 16 bits.
 5. Last modification time, likewise.
 6. Last status change time, likewise.
 7. Size in bytes. (-1, if number is out of range).
 8. File modes, as a string of ten letters or dashes as in ls -l.
    If URL is on an http server, this will return the content-type if possible.
 9. t iff file's gid would change if file were deleted and recreated.
10. inode number.
11. Device number.

If file does not exist, returns nil.
Furl-buffer-visiting
Return the name of a buffer (if any) that is visiting URL.
Furl-get-url-at-point
Get the URL closest to point, but don't change your
position. Has a preference for looking backward when not
directly on a symbol.
Furl-popup-info
Retrieve the HTTP/1.0 headers and display them in a temp buffer.
Furl-retrieve
Retrieve a document over the World Wide Web.
The document should be specified by its fully specified
Uniform Resource Locator.  No parsing is done, just return the
document as the server sent it.  The document is left in the
buffer specified by url-working-buffer.  url-working-buffer is killed
immediately before starting the transfer, so that no buffer-local
variables interfere with the retrieval.  HTTP/1.0 redirection will
be honored before this function exits.
Fw3-use-hotlist
Possibly go to a link in your W3/Mosaic hotlist.
This is part of the emacs World Wide Web browser.  It will prompt for
one of the items in your 'hotlist'.  A hotlist is a list of often
visited or interesting items you have found on the World Wide Web.
Fw3-open-local
Find a local file, and interpret it as a hypertext document.
This is part of the emacs World Wide Web browser.  It will prompt for
an existing file or directory, and retrieve it as a hypertext document.
If it is a directory, and w3-directory-format is 'hypertext, then an
HTML directory listing is created on the fly.  Otherwise, dired-mode is
used to visit the buffer.
Fw3-fetch
Retrieve a document over the World Wide Web.
The World Wide Web is a global hypertext system started by CERN in
Switzerland in 1991.

The document should be specified by its fully specified
Uniform Resource Locator.  The document will be parsed, printed, or
passed to an external viewer as appropriate.  See the variable
mm-mime-info for how to specify a viewer for a file type.
Fw3-batch-fetch
Fetch all the URLs on the command line and save them to files in
the current directory.  The first argument after the -f w3-batch-fetch
on the command line should be a string specifying how to save the
information retrieved.  If it is "html", then the page will be
unformatted when it is written to disk.  If it is "text", then the
page will be formatted before it is written to disk.  If it is
"binary" it will not mess with the file extensions, and just save
the data in raw binary format.  If none of those, the default is
"text", and the first argument is treated as a normal URL.
Fw3-preview-this-buffer
See what this buffer will look like when its formatted as HTML.
HTML is the HyperText Markup Language used by the World Wide Web to
specify formatting for text.  More information on HTML can be found at
info.cern.ch:/pub/www/doc.
Fw3
Retrieve the default World Wide Web home page.
The World Wide Web is a global hypertext system started by CERN in
Switzerland in 1991.

The home page is specified by the variable w3-default-homepage.  The
document should be specified by its fully specified Uniform Resource
Locator.  The document will be parsed as HTML (if appropriate) and
displayed in a new buffer.
Fw3-follow-link
Attempt to follow the hypertext reference under point.
With prefix-arg P, ignore viewers and dump the link straight
to disk.
Fopen-line
Insert a newline and leave point before it.  If there is a fill
prefix, inserts the fill prefix after the newline that it inserts.
With arg, inserts that many newlines.
Fsplit-line
Split current line, moving portion beyond point vertically down.
Fquoted-insert
Read next input character and insert it.
Useful for inserting control characters.
You may also type up to 3 octal digits, to insert a character with that code
Fdelete-indentation
Join this line to previous and fix up whitespace at join.
With argument, join this line to following line.
Ffixup-whitespace
Fixup white space between objects around point.
Leave one space or none, according to the context.
Fdelete-horizontal-space
Delete all spaces and tabs around point.
Fjust-one-space
Delete all spaces and tabs around point, leaving one space.
Fdelete-blank-lines
On blank line, delete all surrounding blank lines, leaving just one.
On isolated blank line, delete that one.
On nonblank line, delete all blank lines that follow it.
Fback-to-indentation
Move point to the first non-whitespace character on this line.
Fnewline-and-indent
Insert a newline, then indent according to major mode.
Indentation is done using the current indent-line-function.
In programming language modes, this is the same as TAB.
In some text modes, where TAB inserts a tab, this indents to the
specified left-margin column.
Freindent-then-newline-and-indent
Reindent current line, insert newline, then indent the new line.
Indentation of both lines is done according to the current major mode,
which means that the current value of indent-line-function is called.
In programming language modes, this is the same as TAB.
In some text modes, where TAB inserts a tab, this indents to the
specified left-margin column.
Fbackward-delete-char-untabify
Delete characters backward, changing tabs into spaces.
Delete ARG chars, and kill (save in kill ring) if KILLP is non-nil.
Interactively, ARG is the prefix arg (default 1)
and KILLP is t if prefix arg is was specified.
Fzap-to-char
Kill up to and including ARG'th occurrence of CHAR.
Goes backward if ARG is negative; error if CHAR not found.
Fbeginning-of-buffer
Move point to the beginning of the buffer; leave mark at previous position.
With arg N, put point N/10 of the way from the true beginning.
Don't use this in Lisp programs!
(goto-char (point-min)) is faster and avoids clobbering the mark.
Fend-of-buffer
Move point to the end of the buffer; leave mark at previous position.
With arg N, put point N/10 of the way from the true end.
Don't use this in Lisp programs!
(goto-char (point-max)) is faster and avoids clobbering the mark.
Fmark-beginning-of-buffer
Push a mark at the beginning of the buffer; leave point where it is.
With arg N, push mark N/10 of the way from the true beginning.
Fmark-end-of-buffer
Push a mark at the end of the buffer; leave point where it is.
With arg N, push mark N/10 of the way from the true end.
Fmark-whole-buffer
Put point at beginning and mark at end of buffer.
Feval-current-buffer
Evaluate the current buffer as Lisp code.
Programs can pass argument PRINTFLAG which controls printing of output:
nil means discard it; anything else is stream for print.
Fcount-lines-region
Print number of lines in the region.
Fwhat-line
Print the current line number (in the buffer) of point.
Fcount-lines
Return number of lines between START and END.
This is usually the number of newlines between them,
but will be one more if START is not equal to END
and the greater of them is not at the start of a line.
Fwhat-cursor-position
Print info on cursor position (on screen and within buffer).
Ffundamental-mode
Major mode not specialized for anything in particular.
Other major modes are defined by comparison with this one.
Feval-expression
Evaluate EXPRESSION and print value in minibuffer.
Value is also consed on to front of the variable `values'.
Fedit-and-eval-command
Prompting with PROMPT, let user edit COMMAND and eval result.
COMMAND is a Lisp expression.  Let user edit that expression in
the minibuffer, then read and evaluate the result.
Frepeat-complex-command
Edit and re-evaluate last complex command, or ARGth from last.
A complex command is one which used the minibuffer.
The command is placed in the minibuffer as a Lisp form for editing.
The result is executed, repeating the command as changed.
If the command has been changed or is not the most recent previous command
it is added to the front of the command history.
You can use the minibuffer history commands \<minibuffer-local-map>\[next-history-element] and \[previous-history-element]
to get different commands to edit and resubmit.
Fgoto-line
Goto line ARG, counting from line 1 at beginning of buffer.
Fundo
Undo some previous changes.
Repeat this command to undo more changes.
A numeric argument serves as a repeat count.
Fundo-start
Move undo-pointer to front of undo records.
The next call to undo-more will undo the most recently made change.
Fundo-more
Undo back N undo-boundaries beyond what was already undone recently.
Call undo-start to get ready to undo recent changes,
then call undo-more one or more times to undo them.
Fshell-command
Execute string COMMAND in inferior shell; display output, if any.
If COMMAND ends in ampersand, execute it asynchronously.

Optional second arg non-nil (prefix arg, if interactive)
means insert output in current buffer after point (leave mark after it).
This cannot be done asynchronously.
Fshell-command-on-region
Execute string COMMAND in inferior shell with region as input.
Normally display output (if any) in temp buffer `*Shell Command Output*';
Prefix arg means replace the region with it.
Noninteractive args are START, END, COMMAND, FLAG.
Noninteractively FLAG means insert output in place of text from START to END,
and put point at the end, but don't alter the mark.

If the output is one line, it is displayed in the echo area,
but it is nonetheless available in buffer `*Shell Command Output*'
even though that buffer is not automatically displayed.  If there is no output
or output is inserted in the current buffer then `*Shell Command Output*' is
deleted.
Funiversal-argument
Begin a numeric argument for the following command.
Digits or minus sign following this command make up the numeric argument.
If no digits or minus sign follow, this command by itself provides 4 as argument.
Used more than once, this command multiplies the argument by 4 each time.
Fdigit-argument
Part of the numeric argument for the next command.
Fnegative-argument
Begin a negative numeric argument for the next command.
Fforward-to-indentation
Move forward ARG lines and position at first nonblank character.
Fbackward-to-indentation
Move backward ARG lines and position at first nonblank character.
Fkill-line
Kill the rest of the current line; if no nonblanks there, kill thru newline.
With prefix argument, kill that many lines from point.
Negative arguments kill lines backward.

When calling from a program, nil means "no arg",
a number counts as a prefix arg.
Vkill-ring
List of killed text sequences.
Vkill-ring-max
*Maximum length of kill ring before oldest elements are thrown away.
Vkill-ring-yank-pointer
The tail of the kill ring whose car is the last thing yanked.
Fkill-region
Kill between point and mark.
The text is deleted but saved in the kill ring.
The command \[yank] can retrieve it from there.
(If you want to kill and then yank immediately, use \[kill-ring-save].)

This is the primitive for programs to kill text (as opposed to deleting it).
Supply two arguments, character numbers indicating the stretch of text
 to be killed.
Any command that calls this function is a "kill command".
If the previous command was also a kill command,
the text killed this time appends to the text killed last time
to make one entry in the kill ring.
Vkill-hooks
If non-nil, this should be a function or functions of one argument which
are called with the string most recently added to the kill ring.  You can use
this to, for example, make the most recent kill become the X Clipboard
selection.
Fcopy-region-as-kill
Save the region as if killed, but don't kill it.
Fkill-ring-save
Save the region as if killed, but don't kill it.
Fappend-next-kill
Cause following command, if kill, to append to previous kill.
Frotate-yank-pointer
Rotate the yanking point in the kill ring.
Fyank-pop
Replace just-yanked stretch of killed-text with a different stretch.
This command is allowed only immediately after a  yank  or a  yank-pop.
At such a time, the region contains a stretch of reinserted
previously-killed text.  yank-pop  deletes that text and inserts in its
place a different stretch of killed text.

With no argument, the previous kill is inserted.
With argument n, the n'th previous kill is inserted.
If n is negative, this is a more recent kill.

The sequence of kills wraps around, so that after the oldest one
comes the newest one.
Fyank
Reinsert the last stretch of killed text.
More precisely, reinsert the stretch of killed text most recently
killed OR yanked.
With just C-U as argument, same but put point in front (and mark at end).
With argument n, reinsert the nth most recently killed stretch of killed
text.
See also the command \[yank-pop].
Finsert-buffer
Insert after point the contents of BUFFER.
Puts mark after the inserted text.
BUFFER may be a buffer or a buffer name.
Fappend-to-buffer
Append to specified buffer the text of the region.
It is inserted into that buffer before its point.

When calling from a program, give three arguments:
a buffer or the name of one, and two character numbers
specifying the portion of the current buffer to be copied.
Fprepend-to-buffer
Prepend to specified buffer the text of the region.
It is inserted into that buffer after its point.

When calling from a program, give three arguments:
a buffer or the name of one, and two character numbers
specifying the portion of the current buffer to be copied.
Fcopy-to-buffer
Copy to specified buffer the text of the region.
It is inserted into that buffer, replacing existing text there.

When calling from a program, give three arguments:
a buffer or the name of one, and two character numbers
specifying the portion of the current buffer to be copied.
Fmark
Return this buffer's mark value as integer, or nil if no mark.

If `zmacs-regions' is true, then this returns nil unless the region is
currently in the active (hilighted) state.  With an argument of t, this
returns the mark (if there is one) regardless of the active-region state.
You should *generally* not use the mark unless the region is active, if
the user has expressed a preference for the active-region model.

If you are using this in an editing command, you are most likely making
a mistake; see the documentation of `set-mark'.
Fset-mark
Set this buffer's mark to POS.  Don't use this function!
That is to say, don't use this function unless you want
the user to see that the mark has moved, and you want the previous
mark position to be lost.

Normally, when a new mark is set, the old one should go on the stack.
This is why most applications should use push-mark, not set-mark.

Novice emacs-lisp programmers often try to use the mark for the wrong
purposes.  The mark saves a location for the user's convenience.
Most editing commands should not alter the mark.
To remember a location for internal use in the Lisp program,
store it in a Lisp variable.  Example:

   (let ((beg (point))) (forward-line 1) (delete-region beg (point))).
Vmark-ring
The list of saved former marks of the current buffer,
most recent first.
Vmark-ring-max
*Maximum size of mark ring.  Start discarding off end if gets this big.
Fset-mark-command
Set mark at where point is, or jump to mark.
With no prefix argument, set mark, and push previous mark on mark ring.
With argument, jump to mark, and pop into mark off the mark ring.

Novice emacs-lisp programmers often try to use the mark for the wrong
purposes.  See the documentation of `set-mark' for more information.
Fpush-mark
Set mark at LOCATION (point, by default) and push old mark on mark ring.
Displays "Mark set" unless the optional second arg NOMSG is non-nil.

Novice emacs-lisp programmers often try to use the mark for the wrong
purposes.  See the documentation of `set-mark' for more information.
Fpop-mark
Pop off mark ring into the buffer's actual mark.
Does not set point.  Does nothing if mark ring is empty.
Fexchange-point-and-mark
Put the mark where point is now, and point where the mark is now.
Vnext-line-extends-end-of-buffer
*If non-nil, when \[next-line] is invoked on the last line of a buffer,
a newline character is inserted to create a new line.
If nil, \[next-line] signals an `end-of-buffer' in that situation.
Fnext-line
Move cursor vertically down ARG lines.
If there is no character in the target line exactly under the current column,
the cursor is positioned after the character in that line which spans this
column, or at the end of the line if it is not long enough.

If the variable `next-line-extends-end-of-buffer' is true and there is no line
in the buffer after this one, a newline character is inserted to create
a line and the cursor moves to that line.

The command \[set-goal-column] can be used to create
a semipermanent goal column to which this command always moves.
Then it does not try to move vertically.  This goal column is stored
in `goal-column', which is nil when there is none.

If you are thinking of using this in a Lisp program, consider
using `forward-line' instead.  It is usually easier to use
and more reliable (no dependence on goal column, etc.).
Fprevious-line
Move cursor vertically up ARG lines.
If there is no character in the target line exactly over the current column,
the cursor is positioned after the character in that line which spans this
column, or at the end of the line if it is not long enough.

The command \[set-goal-column] can be used to create
a semipermanent goal column to which this command always moves.
Then it does not try to move vertically.

If you are thinking of using this in a Lisp program, consider using
`forward-line' with negative argument instead..  It is usually easier
to use and more reliable (no dependence on goal column, etc.).
Vtrack-eol
*Non-nil means vertical motion starting at end of line keeps to ends of lines.
This means moving to the end of each line moved onto.
Vtemporary-goal-column
Current goal column for vertical motion.
It is the column where point was at the start of current run of vertical motion commands.
Fset-goal-column
Set the current horizontal position as a goal for \[next-line] and \[previous-line].
Those commands will move to this position in the line moved to
rather than trying to keep the same horizontal position.
With a non-nil argument, clears out the goal column
so that \[next-line] and \[previous-line] resume vertical motion.
Ftranspose-chars
Interchange characters around point, moving forward one character.
With prefix arg ARG, effect is to take character before point
and drag it forward past ARG other characters (backward if ARG negative).
If no argument and at end of line, the previous two chars are exchanged.
Ftranspose-words
Interchange words around point, leaving point at end of them.
With prefix arg ARG, effect is to take word before or around point
and drag it forward past ARG other words (backward if ARG negative).
If ARG is zero, the words around or after point and around or after mark
are interchanged.
Ftranspose-sexps
Like \[transpose-words] but applies to sexps.
Does not work on a sexp that point is in the middle of
if it is a list or string.
Ftranspose-lines
Exchange current line and previous line, leaving point after both.
With argument ARG, takes previous line and moves it past ARG lines.
With argument 0, interchanges line point is in with line mark is in.
Vcomment-column
*Column to indent right-margin comments to.
Setting this variable automatically makes it local to the current buffer.
Vcomment-start
*String to insert to start a new comment, or nil if no comment syntax defined.
Vcomment-start-skip
*Regexp to match the start of a comment plus everything up to its body.
If there are any \(...\) pairs, the comment delimiter text is held to begin
at the place matched by the close of the first pair.
Vcomment-end
*String to insert to end a new comment.
Should be an empty string if comments are terminated by end-of-line.
Vcomment-indent-hook
Function to compute desired indentation for a comment.
This function is called with no args with point at the beginning of
the comment's starting delimiter.
Findent-for-comment
Indent this line's comment to comment column, or insert an empty comment.
Fset-comment-column
Set the comment column based on point.
With no arg, set the comment column to the current column.
With just minus as arg, kill any comment on this line.
With any other arg, set comment column to indentation of the previous comment
 and then align or create a comment on this line at that column.
Fkill-comment
Kill the comment on this line, if any.
With argument, kill comments on that many lines starting with this one.
Fbackward-word
Move backward until encountering the end of a word.
With argument, do this that many times.
In programs, it is faster to call forward-word with negative arg.
Fmark-word
Set mark arg words away from point.
Fkill-word
Kill characters forward until encountering the end of a word.
With argument, do this that many times.
Fbackward-kill-word
Kill characters backward until encountering the end of a word.
With argument, do this that many times.
Vfill-prefix
*String for filling to insert at front of new line, or nil for none.
Setting this variable automatically makes it local to the current buffer.
Vauto-fill-inhibit-regexp
*Regexp to match lines which should not be auto-filled.
Vcomment-multi-line
*Non-nil means \[indent-new-comment-line] should continue same comment
on new line, with no new terminator or starter.
Findent-new-comment-line
Break line at point and indent, continuing comment if presently within one.
The body of the continued comment is indented under the previous comment line.
Fauto-fill-mode
Toggle auto-fill mode.
With arg, turn auto-fill mode on if and only if arg is positive.
In auto-fill mode, inserting a space at a column beyond  fill-column
automatically breaks the line at a previous space.
Fturn-on-auto-fill
Unconditionally turn on Auto Fill mode.
Fset-fill-column
Set fill-column to current column, or to argument if given.
fill-column's value is separate for each buffer.
Fset-selective-display
Set selective-display to ARG; clear it if no arg.
When selective-display is a number > 0,
lines whose indentation is >= selective-display are not displayed.
selective-display's value is separate for each buffer.

WARNING: selective-display does not currently work with Lucid Emacs.
This is a known bug that will be fixed eventually.
Foverwrite-mode
Toggle overwrite mode.
With arg, turn overwrite mode on iff arg is positive.
In overwrite mode, printing characters typed in replace existing text
on a one-for-one basis, rather than pushing it to the right.
Vblink-matching-paren
*Non-nil means show matching open-paren when close-paren is inserted.
Vblink-matching-paren-distance
*If non-nil, is maximum distance to search for matching open-paren
when close-paren is inserted.
Fblink-matching-open
Move cursor momentarily to the beginning of the sexp before point.
Fkeyboard-quit
Signal a `quit' condition.
Fset-variable
Set VARIABLE to VALUE.  VALUE is a Lisp object.
When using this interactively, supply a Lisp expression for VALUE.
If you want VALUE to be a string, you must surround it with doublequotes.
Vhelp-map
Keymap for characters following the Help key.
Fhelp-with-tutorial
Select the Emacs learn-by-doing tutorial.
Fdescribe-key-briefly
Print the name of the function KEY invokes.  KEY is a string.
Fprint-help-return-message
Display or return message saying how to restore windows after help command.
Computes a message and applies the argument FUNCTION to it.
If FUNCTION is nil, applies `message' to it, thus printing it.
Fdescribe-key
Display documentation of the function KEY invokes.
KEY is a string, or vector of events.  When called interactvely, key may
also be a menu selection.
Fwhere-is
Print message listing key sequences that invoke specified command.
Argument is a command definition, usually a symbol with a function definition.
Fdescribe-mode
Display documentation of current major mode.
Fdescribe-distribution
Display info on how to obtain the latest version of GNU Emacs.
Fdescribe-copying
Display info on how you may redistribute copies of GNU Emacs.
Fdescribe-pointer
Show a list of all defined mouse buttons, and their definitions.
This is the same as \[universal-argument] \[describe-bindings].
Fdescribe-no-warranty
Display info on all the kinds of warranty Emacs does NOT have.
Fview-emacs-news
Display info on recent changes to Emacs.
Fview-winemacs-readme
Display README file for Win-Emacs.
Fview-lossage
Display last 100 input keystrokes.
Fhelp-for-help
You have typed C-h, the help character.  Type a Help option:

A  command-apropos.   Give a substring, and see a list of commands
              (functions interactively callable) that contain
          that substring.  See also the  apropos  command.
B  describe-bindings.  Display table of all key bindings.
C  describe-key-briefly.  Type a command key sequence;
          it prints the function name that sequence runs.
F  describe-function.  Type a function name and get documentation of it.
I  info. The  info  documentation reader.
K  describe-key.  Type a command key sequence;
          it displays the full documentation.
L  view-lossage.  Shows last 100 characters you typed.
M  describe-mode.  Print documentation of current major mode,
          which describes the commands peculiar to it.
N  view-emacs-news.  Shows emacs news file.
P  describe-pointer.  Display table of all mouse-button bindings.
R  view-winemacs-readme.  Shows Win-Emacs README file.
S  describe-syntax.  Display contents of syntax table, plus explanations
T  help-with-tutorial.  Select the Emacs learn-by-doing tutorial.
V  describe-variable.  Type name of a variable;
          it displays the variable's documentation and value.
W  where-is.  Type command name; it prints which keystrokes
          invoke that command.
C-c print Emacs copying permission (General Public License).
C-d print Emacs ordering information.
C-n print news of recent Emacs changes.
C-w print information on absence of warranty for GNU Emacs.
Vdescribe-function-show-arglist
*If true, then describe-function will show its arglist if the function is
not an autoload.
Fdescribe-function
Display the full documentation of FUNCTION (a symbol).
Fdescribe-variable
Display the full documentation of VARIABLE (a symbol).
Fcommand-apropos
Like apropos but lists only symbols that are names of commands
(interactively callable functions).  Argument REGEXP is a regular expression
that is matched against command symbol names.  Returns list of symbols and
documentation found.
Flocate-library
Show the full path name of Emacs library LIBRARY.
This command searches the directories in `load-path' like  M-x load-library
to find the file that  M-x load-library RET LIBRARY RET  would load.
Optional prefix arg NOSUFFIX non-nil means don't add suffixes `.elc' or `.el'
to the specified name LIBRARY - a la calling (load LIBRARY nil nil t).
Vdelete-auto-save-files
*Non-nil means delete a buffer's auto-save file
when the buffer is saved for real.
Vmake-backup-files
*Create a backup of each file when it is saved for the first time.
This can be done by renaming the file or by copying.

Renaming means that Emacs renames the existing file so that it is a
backup file, then writes the buffer into a new file.  Any other names
that the old file had will now refer to the backup file.
The new file is owned by you and its group is defaulted.

Copying means that Emacs copies the existing file into the backup file,
then writes the buffer on top of the existing file.  Any other names
that the old file had will now refer to the new (edited) file.
The file's owner and group are unchanged.

The choice of renaming or copying is controlled by the variables
backup-by-copying, backup-by-copying-when-linked and
backup-by-copying-when-mismatch.
Vbackup-by-copying
*Non-nil means always use copying to create backup files.
See documentation of variable  make-backup-files.
Vbackup-by-copying-when-linked
*Non-nil means use copying to create backups for files with multiple names.
This causes the alternate names to refer to the latest version as edited.
This variable is relevant only if  backup-by-copying  is nil.
Vbackup-by-copying-when-mismatch
*Non-nil means create backups by copying if this preserves owner or group.
Renaming may still be used (subject to control of other variables)
when it would not result in changing the owner or group of the file;
that is, for files which are owned by you and whose group matches
the default for a new file created there by you.
This variable is relevant only if  backup-by-copying  is nil.
Vbuffer-offer-save
*Non-nil in a buffer means offer to save the buffer on exit
even if the buffer is not visiting a file.  Automatically local in
all buffers.
Vfile-precious-flag
*Non-nil means protect against I/O errors while saving files.
Some modes set this non-nil in particular buffers.
Vversion-control
*Control use of version numbers for backup files.
t means make numeric backup versions unconditionally.
nil means make them for files that have some already.
never means do not make them.
Vdired-kept-versions
*When cleaning directory, number of versions to keep.
Vtrim-versions-without-asking
*If true, deletes excess backup versions silently.
Otherwise asks confirmation.
Vkept-old-versions
*Number of oldest versions to keep when a new numbered backup is made.
Vkept-new-versions
*Number of newest versions to keep when a new numbered backup is made.
Includes the new backup.  Must be > 0
Vrequire-final-newline
*Value of t says silently ensure a file ends in a newline when it is saved.
Non-nil but not t says ask user whether to add a newline when there isn't one.
nil means don't add newlines.
Vauto-save-default
*Non-nil says by default do auto-saving of every file-visiting buffer.
Vauto-save-visited-file-name
*Non-nil says auto-save a buffer in the file it is visiting, when practical.
Normally auto-save files are written under other names.
Vsave-abbrevs
*Non-nil means save word abbrevs too when files are saved.
Loading an abbrev file sets this to t.
Vfind-file-run-dired
*Non-nil says run dired if find-file is given the name of a directory.
Vfind-file-not-found-hooks
List of functions to be called for find-file on nonexistent file.
These functions are called as soon as the error is detected.
buffer-file-name is already set up.
The functions are called in the order given,
until one of them returns non-nil.
Vfind-file-hooks
List of functions to be called after a buffer is loaded from a file.
The buffer's local variables (if any) will have been processed before the
functions are called.
Vwrite-file-hooks
List of functions to be called before writing out a buffer to a file.
If one of them returns non-nil, the file is considered already written
and the rest are not called.
These hooks are considered to pertain to the visited file.
So this list is cleared if you change the visited file name.
See also `write-contents-hooks'.
Vwrite-contents-hooks
List of functions to be called before writing out a buffer to a file.
If one of them returns non-nil, the file is considered already written
and the rest are not called.
These hooks are considered to pertain to the buffer's contents,
not to the particular visited file; thus, `set-visited-file-name' does
not clear this variable, but changing the major mode does clear it.
See also `write-file-hooks'.
Vwrite-file-data-hooks
List of functions to be called to put the bytes on disk.
These functions receive the name of the file to write to as argument.
The default behavior is to call
  (write-region (point-min) (point-max) filename nil t)
If one of them returns non-nil, the file is considered already written
and the rest are not called.
These hooks are considered to pertain to the visited file.
So this list is cleared if you change the visited file name.
See also `write-file-hooks'.
Vafter-write-file-hooks
List of functions to be called after writing out a buffer to a file.
These hooks are considered to pertain to the visited file.
So this list is cleared if you change the visited file name.
Venable-local-variables
*Control use of local-variables lists in files you visit.
The value can be t, nil or something else.
A value of t means local-variables lists are obeyed;
nil means they are ignored; anything else means query.

The command \[normal-mode] always obeys local-variables lists
and ignores this variable.
Vignore-local-variable-errors
*If t, ignore errors occurring during local-variable parsing of a file.
This is set to `t' by default, so that files such as X resource files
that may contain -*- in their first line don't cause spurious errors.
Fpwd
Show the current default directory.
Fcd
Make DIR become the current buffer's default directory.
Fload-file
Load the file FILE of Lisp code.
Fload-library
Load the library named LIBRARY.
This is an interface to the function `load'.
Fswitch-to-other-buffer
Switch to the previous buffer.  With a numeric arg, n, switch to the nth
most recent buffer.  With an arg of 0, buries the current buffer at the
bottom of the buffer stack.
Fswitch-to-buffer-other-window
Select buffer BUFFER in another window.
Ffind-file
Edit file FILENAME.
Switch to a buffer visiting file FILENAME,
creating one if none already exists.
Ffind-file-other-window
Edit file FILENAME, in another window.
May create a new window, or reuse an existing one;
see the function display-buffer.
Ffind-file-read-only
Edit file FILENAME but don't allow changes.
Like \[find-file] but marks buffer as read-only.
Use \[toggle-read-only] to permit editing.
Ffind-file-read-only-other-window
Edit file FILENAME in another window but don't allow changes.
Like \[find-file-other-window] but marks buffer as read-only.
Use \[toggle-read-only] to permit editing.
Ffind-alternate-file
Find file FILENAME, select its buffer, kill previous buffer.
If the current buffer now contains an empty file that you just visited
(presumably by mistake), use this command to visit the file you really want.
Fmaybe-compute-file-type
Under MS-DOS et al, determine and set the file type of the buffer.
Under other operating systems, do nothing.  If `auto-compute-file-type-p' is
non-nil, determine the file type from `file-name-file-type-alist' (q.v.);
otherwise, take the file type from `default-file-type'.  BUFFER defaults
to the current buffer if not specified.  Optional second argument FILENAME
is the name of the file the buffer will hold, if the buffer's filename is
not yet set.
Fcreate-file-buffer
Create a suitably named buffer for visiting FILENAME, and return it.
FILENAME (sans directory) is used unchanged if that name is free;
otherwise a string <2> or <3> or ... is appended to get an unused name.
Fcompute-buffer-file-truename
Recomputes this buffer's value of `buffer-file-truename'
based on the current value of `buffer-file-name'.
Ffind-file-noselect
Read file FILENAME into a buffer and return the buffer.
If a buffer exists visiting FILENAME, return that one, but
verify that the file has not changed since visited or saved.
The buffer is not selected, just returned to the caller.
Fafter-find-file
Called after finding a file and by the default revert function.
Sets buffer mode, parses local variables.
Optional args ERROR and WARN: ERROR non-nil means there was an
error in reading the file.  WARN non-nil means warn if there
exists an auto-save file more recent than the visited file.
Finishes by calling the functions in find-file-hooks.
Fnormal-mode
Choose the major mode for this buffer automatically.
Also sets up any specified local variables of the file.
Uses the visited file name, the -*- line, and the local variables spec.

This function is called automatically from `find-file'.  In that case,
we may set up specified local variables depending on the value of
`enable-local-variables': if it is t, we do; if it is nil, we don't;
otherwise, we query.  `enable-local-variables' is ignored if you
run `normal-mode' explicitly.
Fset-auto-mode
Select major mode appropriate for current buffer.
May base decision on visited file name (see variable `auto-mode-alist') or on
buffer contents (the -*- line), but does not look for the "mode:" local
variable spec in the last page.  For that, use `hack-local-variables'.
Fhack-local-variables
Parse, and bind or evaluate as appropriate, any local variables
for current buffer.
Fset-visited-file-name
Change name of file visited in current buffer to FILENAME.
The next time the buffer is saved it will go in the newly specified file.
nil or empty string as argument means make buffer not be visiting any file.
Remember to delete the initial contents of the minibuffer
if you wish to pass an empty string as the argument.
Fwrite-file
Write current buffer into file FILENAME.
Makes buffer visit that file, and marks it not modified.
Fbackup-buffer
Make a backup of the disk file visited by the current buffer, if appropriate.
This is normally done before saving the buffer the first time.
If the value is non-nil, it is the result of `file-modes' on the original file;
this means that the caller, after saving the buffer, should change the modes
of the new file to agree with the old modes.
Ffile-name-sans-versions
Return FILENAME sans backup versions or strings.
This is a separate procedure so your site-init or startup file can
redefine it.
Fmake-backup-file-name
Create the non-numeric backup file name for FILE.
This is a separate function so you can redefine it for customization.
Fbackup-file-name-p
Return non-nil if FILE is a backup file name (numeric or not).
This is a separate function so you can redefine it for customization.
You may need to redefine file-name-sans-versions as well.
Ffind-backup-file-name
Find a file name for a backup file, and suggestions for deletions.
Value is a list whose car is the name for the backup file
 and whose cdr is a list of old versions to consider deleting now.
Ffile-nlinks
Return number of names file FILENAME has.
Ffile-relative-name
Convert FILENAME to be relative to DIRECTORY (default: default-directory).
Fsave-buffer
Save current buffer in visited file if modified.  Versions described below.

By default, makes the previous version into a backup file
 if previously requested or if this is the first save.
With 1 or 3 \[universal-argument]'s, marks this version
 to become a backup when the next save is done.
With 2 or 3 \[universal-argument]'s,
 unconditionally makes the previous version into a backup file.
With argument of 0, never makes the previous version into a backup file.

If a file's name is FOO, the names of its numbered backup versions are
 FOO.~i~ for various integers i.  A non-numbered backup file is called FOO~.
Numeric backups (rather than FOO~) will be made if value of
 `version-control' is not the atom `never' and either there are already
 numeric versions of the file being backed up, or `version-control' is
 non-nil.
We don't want excessive versions piling up, so there are variables
 `kept-old-versions', which tells Emacs how many oldest versions to keep,
 and `kept-new-versions', which tells how many newest versions to keep.
 Defaults are 2 old versions and 2 new.
`dired-kept-versions' controls dired's clean-directory (.) command.
If `trim-versions-without-asking' is nil, system will query user
 before trimming versions.  Otherwise it does it silently.
Fdelete-auto-save-file-if-necessary
Delete the auto-save filename for the current buffer (if it has one)
if variable `delete-auto-save-files' is non-nil.
Normally delete only if the file was written by this Emacs
since the last real save, but optional arg FORCE non-nil means delete anyway.
Fbasic-save-buffer
Save the current buffer in its visited file, if it has been modified.
Fsave-some-buffers
Save some modified file-visiting buffers.  Asks user about each one.
Optional argument (the prefix) non-nil means save all with no questions.
Optional second argument EXITING means ask about certain non-file buffers
 as well as about file buffers.
Fnot-modified
Mark current buffer as unmodified, not needing to be saved.
With prefix arg, mark buffer as modified, so \[save-buffer] will save.
Ftoggle-read-only
Change whether this buffer is visiting its file read-only.
With arg, set read-only iff arg is positive.
Finsert-file
Insert contents of file FILENAME into buffer after point.
Set mark after the inserted text.

This function is meant for the user to run interactively.
Don't call it from programs!  Use `insert-file-contents' instead.
(Its calling sequence is different; see its documentation).
Fappend-to-file
Append the contents of the region to the end of file FILENAME.
When called from a function, expects three arguments,
START, END and FILENAME.  START and END are buffer positions
saying what text to write.
Ffile-newest-backup
Return most recent backup file for FILENAME or nil if no backups exist.
Frename-uniquely
Rename current buffer to a similar name not already taken.
This function is useful for creating multiple shell process buffers
or multiple mail buffers, etc.
Fmake-directory-path
Create all the directories along path that don't exist yet.
Vrevert-buffer-function
Function to use to revert this buffer, or nil to do the default.
Vrevert-buffer-insert-file-contents-function
Function to use to insert contents when reverting this buffer.
Gets two args, first the nominal file name to use,
and second, t if reading the auto-save file.
Frevert-buffer
Replace the buffer text with the text of the visited file on disk.
This undoes all changes since the file was visited or saved.
With a prefix argument, offer to revert from latest auto-save file, if
that is more recent than the visited file.
When called from lisp, this is the first argument, CHECK-AUTO; it is optional.
Optional second argument NOCONFIRM means don't ask for confirmation at all.

If the value of `revert-buffer-function' is non-nil, it is called to
do the work.
Frecover-file
Visit file FILE, but get contents from its last auto-save file.
Fkill-some-buffers
For each buffer, ask whether to kill it.
Fauto-save-mode
Toggle auto-saving of contents of current buffer.
With arg, turn auto-saving on if arg is positive, else off.
Frename-auto-save-file
Adjust current buffer's auto save file name for current conditions.
Also rename any existing auto save file, if it was made in this session.
Fmake-auto-save-file-name
Return file name to use for auto-saves of current buffer.
Does not consider auto-save-visited-file-name; that is checked
before calling this function.
You can redefine this for customization.
See also auto-save-file-name-p.
Fauto-save-file-name-p
Return non-nil if FILENAME can be yielded by make-auto-save-file-name.
FILENAME should lack slashes.
You can redefine this for customization.
Vlist-directory-brief-switches
*Switches for list-directory to pass to `ls' for brief listing,
Vlist-directory-verbose-switches
*Switches for list-directory to pass to `ls' for verbose listing,
Flist-directory
Display a list of files in or matching DIRNAME, a la `ls'.
DIRNAME is globbed by the shell if necessary.
Prefix arg (second arg if noninteractive) means supply -l switch to `ls'.
Actions controlled by variables list-directory-brief-switches
 and list-directory-verbose-switches.
Fsave-buffers-kill-emacs
Offer to save each buffer, then kill this Emacs process.
With prefix arg, silently save all file-visiting buffers, then kill.
Findent-according-to-mode
Indent line in proper way for current major mode.
Findent-for-tab-command
Indent line in proper way for current major mode.
Findent-rigidly
Indent all lines starting in the region sideways by ARG columns.
Called from a program, takes three arguments, START, END and ARG.
Vindent-region-function
Function which is short cut to indent each line in region with TAB.
A value of nil means really perform TAB on each line.
Findent-region
Indent each nonblank line in the region.
With no argument, indent each line with TAB.
(If there is a fill prefix, make each line start with the fill prefix.)
With argument COLUMN, indent each line to that column.
Called from a program, takes three args: START, END and COLUMN.
Findent-relative-maybe
Indent a new line like previous nonblank line.
Findent-relative
Space out to under next indent point in previous nonblank line.
An indent point is a non-whitespace character following whitespace.
If the previous nonblank line has no indent points beyond
the column point starts at, `tab-to-tab-stop' is done instead.
Vtab-stop-list
*List of tab stop positions used by `tab-to-tab-stops'.
Vedit-tab-stops-map
Keymap used in `edit-tab-stops'.
Vedit-tab-stops-buffer
Buffer whose tab stops are being edited--in case
the variable `tab-stop-list' is local in that buffer.
Fedit-tab-stops
Edit the tab stops used by tab-to-tab-stop.
Creates a buffer *Tab Stops* containing text describing the tab stops.
A colon indicates a column where there is a tab stop.
You can add or remove colons and then do C-c C-c to make changes take effect.
Fedit-tab-stops-note-changes
Put edited tab stops into effect.
Ftab-to-tab-stop
Insert spaces or tabs to next defined tab-stop column.
The variable `tab-stop-list' is a list of columns at which there are tab stops.
Use \[edit-tab-stops] to edit them interactively.
Fmove-to-tab-stop
Move point to next defined tab-stop column.
The variable `tab-stop-list' is a list of columns at which there are tab stops.
Use \[edit-tab-stops] to edit them interactively.
Fcount-windows
Returns the number of visible windows.
Optional arg NO-MINI non-nil means don't count the minibuffer
even if it is active.
Fbalance-windows
Makes all visible windows the same size (approximately).
Fsplit-window-vertically
Split current window into two windows, one above the other.
The top window gets ARG lines.  No arg means split equally.

The two windows will be displaying the same text as before: both windows will
be displaying the current buffer, but the second window will be scrolled such
that little redisplay will happen - the lines that were on the screen before
the split will still be on the screen, in the same places.

An effort is made to keep the cursor in the same place relative to the text on
the screen as well.  If the cursor is below the split-point before the split,
then the bottom window will be selected; otherwise the top window will be
selected.
Fsplit-window-horizontally
Split current window into two windows side by side.
This window becomes the leftmost of the two, and gets
ARG columns.  No arg means split equally.
Fenlarge-window-horizontally
Make current window ARG columns wider.
Fshrink-window-horizontally
Make current window ARG columns narrower.
Fwindow-config-to-register
Save the current window configuration in register REG (a letter).
It can be later retrieved using \[M-x register-to-window-config].
Fregister-to-window-config
Restore (make current) the window configuration in register REG (a letter).
Use with a register previously set with \[window-config-to-register].
Fbackward-other-window
Select the ARG'th different window on this screen, going backwards.
This is just like calling `other-window' with the arg negated.
Fscroll-other-window-down
Scroll the "other window" down.
Fbeginning-of-buffer-other-window
Move point to the beginning of the buffer in the other window.
Leave mark at previous position.
With arg N, put point N/10 of the way from the true beginning.
Fend-of-buffer-other-window
Move point to the end of the buffer in the other window.
Leave mark at previous position.
With arg N, put point N/10 of the way from the true end.
Vdirectory-abbrev-alist
*Alist of abbreviations for file directories.
A list of elements of the form (FROM . TO), each meaning to replace
FROM with TO when it appears in a directory name.
This replacement is done when setting up the default directory of a
newly visited file.  *Every* FROM string should start with \\` or ^.

Use this feature when you have directories which you normally refer to
via absolute symbolic links.  Make TO the name of the link, and FROM
the name it is linked to.
Fabbreviate-file-name
Return a version of FILENAME shortened using directory-abbrev-alist.
See \[describe-variable] directory-abbrev-alist RET for more information.
If optional argument HACK-HOMEDIR is non-nil, then This also substitutes
"~" for the user's home directory.
Vcommand-line-processed
t once command line has been processed
Vinhibit-startup-message
*Non-nil inhibits the initial startup messages.
This is for use in your personal init file, once you are familiar
with the contents of the startup message.
Vinhibit-default-init
*Non-nil inhibits loading the `default' library.
Vcommand-switch-alist
Alist of command-line switches.
Elements look like (SWITCH-STRING . HANDLER-FUNCTION).
HANDLER-FUNCTION receives switch name as sole arg;
remaining command-line args are in the variable `command-line-args-left'.
Vterm-setup-hook
Function to be called after loading terminal-specific lisp code.
It is called with no arguments.  This variable exists for users to set,
so as to override the definitions made by the terminal-specific file.
Emacs never sets this variable itself.
Vkeyboard-type
The brand of keyboard you are using.  This variable is used to define
the proper function and keypad keys for use under X.  It is used in a
fashion analogous to the environment value TERM.
Vwindow-setup-hook
Function used to initialize window system display, after command line args.
Users should not set this variable; use term-setup-hook instead.
Vinitial-major-mode
Major mode command symbol to use for the initial *scratch* buffer.
Vinit-file-user
When the `.emacs' file is read, this says which user's init file it is.
The value may be the null string or a string containing a user's name.
If the value is a null string, it means that the init file was taken from
the user that originally logged in.

In all cases, `(concat "~" init-file-user "/")' evaluates to the
directory name of the directory where the `.emacs' file was looked for.
Vsite-run-file
File containing site-wide run-time initializations.
This file is loaded at run-time before ~/.emacs.  It contains inits
that need to be in place for the entire site, but which, due to their
higher incidence of change, don't make sense to load into emacs'
dumped image.  Thus, the run-time load order is: 1. file described in
this variable, if non-nil; 2. ~/.emacs; 3. default.el.
Vinit-file-name
Name of the initialization file.
This is normally `~/.emacs' on Unix and `emacs.ini' on PC's.
Vdefun-prompt-regexp
Non-nil => regexp to ignore, before the `(' that starts a defun.
Fforward-sexp
Move forward across one balanced expression (sexp).
With argument, do it that many times.
Negative arg -N means move backward across N balanced expressions.
Fbackward-sexp
Move backward across one balanced expression (sexp).
With argument, do it that many times.
Negative arg -N means move forward across N balanced expressions.
Fmark-sexp
Set mark ARG sexps from point.
The place mark goes is the same place \[forward-sexp] would move to
with the same argument.
Fforward-list
Move forward across one balanced group of parentheses.
With argument, do it that many times.
Negative arg -N means move backward across N groups of parentheses.
Fbackward-list
Move backward across one balanced group of parentheses.
With argument, do it that many times.
Negative arg -N means move forward across N groups of parentheses.
Fdown-list
Move forward down one level of parentheses.
With argument, do this that many times.
A negative argument means move backward but still go down a level.
In Lisp programs, an argument is required.
Fbackward-up-list
Move backward out of one level of parentheses.
With argument, do this that many times.
A negative argument means move forward but still to a less deep spot.
In Lisp programs, an argument is required.
Fup-list
Move forward out of one level of parentheses.
With argument, do this that many times.
A negative argument means move backward but still to a less deep spot.
In Lisp programs, an argument is required.
Fkill-sexp
Kill the sexp (balanced expression) following the cursor.
With argument, kill that many sexps after the cursor.
Negative arg -N means kill N sexps before the cursor.
Fbackward-kill-sexp
Kill the sexp (balanced expression) preceding the cursor.
With argument, kill that many sexps before the cursor.
Negative arg -N means kill N sexps after the cursor.
Fbeginning-of-defun
Move backward to the beginning of a defun.
With argument, do it that many times.  Negative arg -N
means move forward to Nth following beginning of defun.
Returns t unless search stops due to beginning or end of buffer.

Normally a defun starts when there is an char with open-parenthesis
syntax at the beginning of a line.  If `defun-prompt-regexp' is
non-nil, then a string which matches that regexp may precede the
open-parenthesis.
Fend-of-defun
Move forward to next end of defun.  With argument, do it that many times.
Negative argument -N means move back to Nth preceding end of defun.

An end of a defun occurs right after the close-parenthesis that matches
the open-parenthesis that starts a defun; see `beginning-of-defun'.
Fmark-defun
Put mark at end of this defun, point at beginning.
The defun marked is the one that contains point or follows point.
Finsert-parentheses
Put parentheses around next ARG sexps.  Leave point after open-paren.
No argument is equivalent to zero: just insert () and leave point between.
Fmove-past-close-and-reindent
Move past next `)', delete indentation before it, then indent after it.
Flisp-complete-symbol
Perform completion on Lisp symbol preceding point.
That symbol is compared against the symbols that exist
and any additional characters determined by what is there
are inserted.
If the symbol starts just after an open-parenthesis,
only symbols with function definitions are considered.
Otherwise, all symbols with function definitions, values
or properties are considered.
Fforward-page
Move forward to page boundary.  With arg, repeat, or go back if negative.
A page boundary is any line whose beginning matches the regexp  page-delimiter.
Fbackward-page
Move backward to page boundary.  With arg, repeat, or go fwd if negative.
A page boundary is any line whose beginning matches the regexp  page-delimiter.
Fmark-page
Put mark at end of page, point at beginning.
A numeric arg specifies to move forward or backward by that many pages,
thus marking a page other than the one point was originally in.
Fnarrow-to-page
Make text outside current page invisible.
A numeric arg specifies to move forward or backward by that many pages,
thus showing a page other than the one point was originally in.
Fcount-lines-page
Report number of lines on current page, and how many are before or after point.
Fwhat-page
Print page and line number of point.
Vregister-alist
Alist of elements (NAME . CONTENTS), one for each Emacs register.
NAME is a character (a number).  CONTENTS is a string, number,
mark or list.  A list represents a rectangle; its elements are strings.
Fget-register
Return contents of Emacs register named CHAR, or nil if none.
Fset-register
Set contents of Emacs register named CHAR to VALUE.
Returns VALUE.
Fpoint-to-register
Store current location of point in a register.
Argument is a character, naming the register.
Fjump-to-register
Move point to location stored in a register.
Argument is a character, naming the register.
Fview-register
Display what is contained in register named REGISTER.
REGISTER is a character.
Finsert-register
Insert contents of register REG.  REG is a character.
Normally puts point before and mark after the inserted text.
If optional second arg is non-nil, puts mark before and point after.
Interactively, second arg is non-nil if prefix arg is supplied.
Fcopy-to-register
Copy region into register REG.
With prefix arg, delete as well.
Called from program, takes four args:
REG, START, END and DELETE-FLAG.
START and END are buffer positions indicating what to copy.
Fappend-to-register
Append region to text in register REG.
With prefix arg, delete as well.
Called from program, takes four args:
REG, START, END and DELETE-FLAG.
START and END are buffer positions indicating what to append.
Fprepend-to-register
Prepend region to text in register REG.
With prefix arg, delete as well.
Called from program, takes four args:
REG, START, END and DELETE-FLAG.
START and END are buffer positions indicating what to prepend.
Fcopy-rectangle-to-register
Copy rectangular region into register REG.
With prefix arg, delete as well.
Called from program, takes four args:
REG, START, END and DELETE-FLAG.
START and END are buffer positions giving two corners of rectangle.
Viso8859/1-case-table
The case table for ISO-8859/1 characters.
Vparagraph-ignore-fill-prefix
Non-nil means the paragraph commands are not affected by fill-prefix.
This is desirable in modes where blank lines are the paragraph delimiters.
Fforward-paragraph
Move forward to end of paragraph.
With arg N, do it N times; negative arg -N means move forward N paragraphs.

A line which `paragraph-start' matches either separates paragraphs
(if `paragraph-separate' matches it also) or is the first line of a paragraph.
A paragraph end is the beginning of a line which is not part of the paragraph
to which the end of the previous line belongs, or the end of the buffer.
Fbackward-paragraph
Move backward to start of paragraph.
With arg N, do it N times; negative arg -N means move forward N paragraphs.

A paragraph start is the beginning of a line which is a first-line-of-paragraph
or which is ordinary text and follows a paragraph-separating line; except:
if the first real line of a paragraph is preceded by a blank line,
the paragraph starts at that blank line.
See forward-paragraph for more information.
Fmark-paragraph
Put point at beginning of this paragraph, mark at end.
The paragraph marked is the one that contains point or follows point.
Fkill-paragraph
Kill forward to end of paragraph.
With arg N, kill forward to Nth end of paragraph;
negative arg -N means kill backward to Nth start of paragraph.
Fbackward-kill-paragraph
Kill back to start of paragraph.
With arg N, kill back to Nth start of paragraph;
negative arg -N means kill forward to Nth end of paragraph.
Ftranspose-paragraphs
Interchange this (or next) paragraph with previous one.
Fforward-sentence
Move forward to next sentence-end.  With argument, repeat.
With negative argument, move backward repeatedly to sentence-beginning.

The variable `sentence-end' is a regular expression that matches ends
of sentences.  Also, every paragraph boundary terminates sentences as
well.
Fbackward-sentence
Move backward to start of sentence.  With arg, do it arg times.
See forward-sentence for more information.
Fkill-sentence
Kill from point to end of sentence.
With arg, repeat; negative arg -N means kill back to Nth start of sentence.
Fbackward-kill-sentence
Kill back from point to start of sentence.
With arg, repeat, or kill forward to Nth end of sentence if negative arg -N.
Fmark-end-of-sentence
Put mark at end of sentence.  Arg works as in forward-sentence.
Ftranspose-sentences
Interchange this (next) and previous sentence.
Fset-fill-prefix
Set the fill-prefix to the current line up to point.
Filling expects lines to start with the fill prefix
and reinserts the fill prefix in each resulting line.
Ffill-region-as-paragraph
Fill region as one paragraph: break lines to fit fill-column.
Prefix arg means justify too.
From program, pass args FROM, TO and JUSTIFY-FLAG.
Ffill-paragraph
Fill paragraph at or after point.
Prefix arg means justify as well.
Ffill-region
Fill each of the paragraphs in the region.
Prefix arg (non-nil third arg, if called from program)
means justify as well.
Fjustify-current-line
Add spaces to line point is in, so it ends at fill-column.
Ffill-individual-paragraphs
Fill each paragraph in region according to its individual fill prefix.
Calling from a program, pass range to fill as first two arguments.
Optional third and fourth arguments JUSTIFY-FLAG and MAIL-FLAG:
JUSTIFY-FLAG to justify paragraphs (prefix arg),
MAIL-FLAG for a mail message, i. e. don't fill header lines.
Vsearch-last-string
Last string search for by a search command.
This does not include direct calls to the primitive search functions,
and does not include searches that are aborted.
Vsearch-last-regexp
Last string searched for by a regexp search command.
This does not include direct calls to the primitive search functions,
and does not include searches that are aborted.
Vsearch-exit-option
Non-nil means random control characters terminate incremental search.
Vsearch-slow-window-lines
*Number of lines in slow search display windows.
These are the short windows used during incremental search on slow terminals.
Negative means put the slow search window at the top (normally it's at bottom)
and the value is minus the number of lines.
Vsearch-slow-speed
*Highest terminal speed at which to use "slow" style incremental search.
This is the style where a one-line window is created to show the line
that the search has reached.
Vsearch-caps-disable-folding
*If non-nil, upper case chars disable case fold searching.
This does not apply to "yanked" strings.
Vsearch-nonincremental-instead
*If non-nil, do a nonincremental search instead if exiting immediately.
Vsearch-whitespace-regexp
*If non-nil, regular expression to match a sequence of whitespace chars.
Vsearch-ring
List of search string sequences.
Vregexp-search-ring
List of regular expression search string sequences.
Vsearch-ring-max
*Maximum length of search ring before oldest elements are thrown away.
Vregexp-search-ring-max
*Maximum length of regexp search ring before oldest elements are thrown away.
Vsearch-ring-yank-pointer
The tail of the search ring whose car is the last thing searched for.
Vregexp-search-ring-yank-pointer
The tail of the regular expression search ring whose car is the last
thing searched for.
Visearch-mode-map
Keymap for isearch-mode.
Vminibuffer-local-isearch-map
Keymap for editing isearch strings in the minibuffer.
Visearch-mode-hook
Function(s) to call after starting up an incremental search.
Visearch-mode-end-hook
Function(s) to call after terminating an incremental search.
Fisearch-forward
Do incremental search forward.
With a prefix argument, do an incremental regular expression search instead.
\<isearch-mode-map>
As you type characters, they add to the search string and are found.
The following non-printing keys are bound in `isearch-mode-map'.

Type \[isearch-delete-char] to cancel characters from end of search string.
Type \[isearch-exit] to exit, leaving point at location found.
Type LFD (C-j) to match end of line.
Type \[isearch-repeat-forward] to search again forward, \[isearch-repeat-backward] to search again backward.
Type \[isearch-yank-word] to yank word from buffer onto end of search string and search for it.
Type \[isearch-yank-line] to yank rest of line onto end of search string and search for it.
Type \[isearch-quote-char] to quote control character to search for it.
Type \[isearch-whitespace-chars] to match all whitespace chars in regexp.
\[isearch-abort] while searching or when search has failed cancels input back to what has
 been found successfully.
\[isearch-abort] when search is successful aborts and moves point to starting point.

Also supported is a search ring of the previous 16 search strings.
Type \[isearch-ring-advance] to search for the next item in the search ring.
Type \[isearch-ring-retreat] to search for the previous item in the search ring.
Type \[isearch-complete] to complete the search string using the search ring.

The above keys are bound in the isearch-mode-map.  To change the keys which
 are special to isearch-mode, simply change the bindings in that map.

Other control and meta characters terminate the search
 and are then executed normally (depending on `search-exit-option').

If this function is called non-interactively, it does not return to
the calling function until the search is done.

The bindings, more precisely:
\{isearch-mode-map}
Fisearch-forward-regexp
Do incremental search forward for regular expression.
Like ordinary incremental search except that your input
is treated as a regexp.  See \[isearch-forward] for more info.
Fisearch-backward
Do incremental search backward.
With a prefix argument, do an incremental regular expression search instead.
See \[isearch-forward] for more information.
Fisearch-backward-regexp
Do incremental search backward for regular expression.
Like ordinary incremental search except that your input
is treated as a regexp.  See \[isearch-forward] for more info.
Fisearch-mode
Start isearch minor mode.  Called by isearch-forward, etc.
Fisearch-exit
Exit search normally.
However, if this is the first command after starting incremental
search and `search-nonincremental-instead' is non-nil, do a
nonincremental search instead.
Fisearch-edit-string
Edit the search string in the minibuffer.
The following additional command keys are active while editing.
\<minibuffer-local-isearch-map>
\[exit-minibuffer] to exit editing and resume incremental searching.
\[isearch-forward-exit-minibuffer] to resume isearching forward.
\[isearch-backward-exit-minibuffer] to resume isearching backward.
\[isearch-ring-advance-edit] to replace the search string with the next item in the search ring.
\[isearch-ring-retreat-edit] to replace the search string with the next item in the search ring.
\[isearch-complete-edit] to complete the search string from the search ring.
Fisearch-abort
Quit incremental search mode if searching is successful, signalling quit.
Otherwise, revert to previous successful search and continue searching.
Use `isearch-exit' to quit without signalling.
Fisearch-repeat-forward
Repeat incremental search forwards.
Fisearch-repeat-backward
Repeat incremental search backwards.
Fisearch-toggle-regexp
Toggle regexp searching on or off.
Fisearch-delete-char
Discard last input item and move point back.
If no previous match was done, just beep.
Fisearch-yank-word
Pull next word from buffer into search string.
Fisearch-yank-line
Pull rest of line from buffer into search string.
Fisearch-yank-x-selection
Pull the current X selection into the search string.
Fisearch-*-char
Handle * and ? specially in regexps.
Fisearch-|-char
If in regexp search, jump to the barrier.
Fisearch-quote-char
Quote special characters for incremental search.
Fisearch-return-char
Convert return into newline for incremental search.
Obsolete.
Fisearch-printing-char
Any other printing character => add it to the search string and search.
Fisearch-whitespace-chars
Match all whitespace chars, if in regexp mode.
Vsearch-ring-update
*Non-nil if advancing or retreating in the search ring should cause search.
Default nil means edit the string from the search ring first.
Fisearch-ring-advance
Advance to the next search string in the ring.
Fisearch-ring-retreat
Retreat to the previous search string in the ring.
Fisearch-ring-adjust-edit
Use the next or previous search string in the ring while in minibuffer.
Fisearch-ring-retreat-edit
Retreat to the previous search string in the ring while in the minibuffer.
Fisearch-complete
Complete the search string from the strings on the search ring.
The completed string is then editable in the minibuffer.
If there is no completion possible, say so and continue searching.
Fisearch-complete-edit
Same as `isearch-complete' except in the minibuffer.
Visearch-highlight
*Whether isearch and query-replace should highlight the text which
currently matches the search-string.
Fisearch-no-upper-case-p
Return t if there are no upper case chars in string.
But upper case chars preceeded by \ do not count since they
have special meaning in a regexp.
Fkeep-lines
Delete all lines except those containing matches for REGEXP.
A match split across lines preserves all the lines it lies in.
Applies to all lines after point.
Fflush-lines
Delete lines containing matches for REGEXP.
If a match is split across lines, all the lines it lies in are deleted.
Applies to lines after point.
Fhow-many
Print number of matches for REGEXP following point.
Foccur-mode
Major mode for output from \[occur].
Move point to one of the occurrences in this buffer,
then use \[occur-mode-goto-occurrence] to go to the same occurrence
in the buffer that the occurrences were found in.
\{occur-mode-map}
Foccur-mode-goto-occurrence
Go to the line this occurrence was found in, in the buffer it was found in.
Vlist-matching-lines-default-context-lines
*Default number of context lines to include around a list-matching-lines
match.  A negative number means to include that many lines before the match.
A positive number means to include that many lines both before and after.
Voccur-whole-buffer
If t, occur operates on whole buffer, otherwise occur starts from point.
default is nil.
Foccur
Show lines containing a match for REGEXP.  If the global variable
occur-whole-buffer is non-nil, the entire buffer is searched, otherwise
search begins at point.  Interactively, REGEXP defaults to the last REGEXP
used interactively.

Each line is displayed with NLINES lines before and after,
or -NLINES before if NLINES is negative.
NLINES defaults to list-matching-lines-default-context-lines.
Interactively it is the prefix arg.

The lines are shown in a buffer named *Occur*.
It serves as a menu to find any of the occurrences in this buffer.
\[describe-mode] in that buffer will explain how.
Vquery-replace-help
Help message while in query-replace
Fperform-replace
Subroutine of `query-replace'.  Its complexity handles interactive queries.
Don't use this in your own program unless you want to query and set the mark
just as `query-replace' does.  Instead, write a simple loop like this:
  (while (re-search-forward "foo[     ]+bar" nil t)
    (replace-match "foobar" nil nil))
which will run faster and do exactly what you probably want.
Fmap-query-replace-regexp
Replace some matches for REGEXP with various strings, in rotation.
The second argument TO-STRINGS contains the replacement strings, separated
by spaces.  This command works like `query-replace-regexp' except
that each successive replacement uses the next successive replacement string,
wrapping around from the last such string to the first.

Non-interactively, TO-STRINGS may be a list of replacement strings.

A prefix argument N says to use each replacement string N times
before rotating to the next.
Vpi
The value of Pi (3.1415926...)
Ve
The value of e (2.7182818...)
Vdegrees-to-radians
Degrees to radian conversion constant
Vradians-to-degrees
Radian to degree conversion constant
Fdegrees-to-radians
Convert ARG from degrees to radians.
Fradians-to-degrees
Convert ARG from radians to degrees.
Vselect-screen-hook
Function or functions to run just after a new screen is selected.
Vdeselect-screen-hook
Function or functions to run just before selecting another screen.
Vscreen-default-alist
Alist of default values for screen creation, other than the first one.
These may be set in your init file, like this:
  (setq screen-default-alist '((width . 80) (height . 55)))
For values specific to the first emacs screen, you must use X resources.
Vminibuffer-alist
Alist of switches for the appearance of the detached minibuffer screen.
Vinitial-screen-hooks
Hook to run after initial screen startup.
Vscreen-creation-func
Window-system dependent function for creating new screens.
Vnew-screen-x-delta
Horizontal displacement (in pixels) for position of new screen.
Vnew-screen-y-delta
Vertical displacement (in pixels) for position of new screen.
Fother-window-any-screen
Select the ARG'th different window on any screen.
All windows on current screen are arranged in a cyclic order.
This command selects the window ARG steps away in that order.
A negative ARG moves in the opposite order.  However, unlike
`other-window', this command will select a window on the next
(or previous) screen instead of wrapping around to the top
(or bottom) of this screen, when there are no more windows.
Fone-screen
Delete all screens but SCREEN (default is current screen).
Also delete all windows but the selected one on SCREEN.
Ffind-file-new-screen
Just like find-file, but creates a new screen for it first.
Fswitch-to-buffer-new-screen
Just like switch-to-buffer, but creates a new screen for it first.
Vauto-raise-screen
*If true, screens will be raised to the top when selected.
Under X, most ICCCM-compliant window managers will have an option to do this
for you, but this variable is provided in case you're using a broken WM.
Vauto-lower-screen
*If true, screens will be lowered to the bottom when no longer selected.
Under X, most ICCCM-compliant window managers will have an option to do this
for you, but this variable is provided in case you're using a broken WM.
Fdefault-select-screen-hook
Implements the `auto-raise-screen' variable.
For use as the value of `select-screen-hook'.
Fdefault-deselect-screen-hook
Implements the `auto-lower-screen' variable.
For use as the value of `deselect-screen-hook'.
Vget-screen-for-buffer-default-screen-name
The default screen to select; see doc of `get-screen-for-buffer'.
Fget-screen-for-buffer
Select and return a screen in which to display BUFFER.
Normally, the buffer will simply be displayed in the current screen.
But if the symbol naming the major-mode of the buffer has a 'screen-name
property (which should be a symbol), then the buffer will be displayed in
a screen of that name.  If there is no screen of that name, then one is
created.

If the major-mode doesn't have a 'screen-name property, then the screen
named by `get-screen-for-buffer-default-screen-name' will be used.  If
that is nil (the default) then the currently selected screen will used.

If the screen-name symbol has an 'instance-limit property (an integer)
then each time a buffer of the mode in question is displayed, a new screen
with that name will be created, until there are `instance-limit' of them.
If instance-limit is 0, then a new screen will be created each time.

If a buffer is already displayed in a screen, then `instance-limit' is
ignored, and that screen is used.

If the screen-name symbol has a 'screen-defaults property, then that is
prepended to the `screen-default-alist' when creating a screen for the
first time.

This function may be used as the value of `pre-display-buffer-hook', to
cause the display-buffer function and its callers to exhibit the above
behavior.
Fshow-temp-buffer-in-current-screen
For use as the value of temp-buffer-show-function:
always displays the buffer in the current screen, regardless of the behavior
that would otherwise be introduced by the `pre-display-buffer-function', which
is normally set to `get-screen-for-buffer' (which see.)
Fkill-this-buffer
Kills the current buffer.
Fx-new-screen
Creates a new emacs screen (that is, a new X window.)
Fx-set-font
Interactively set the default and modeline fonts.
Fx-set-foreground-color
Set the foreground color for the default face.
If the modeline's background color is the same as the default foreground
color, it will be changed too.
Fx-set-background-color
Set the background color for the default face.
If the modeline's foreground color is the same as the default background
color, it will be changed too.
Fset-menubar
Set the default menubar to be menubar.
Fset-buffer-menubar
Set the buffer-local menubar to be menubar.
Ffind-menu-item
Searches MENUBAR for item given by ITEM-PATH-LIST.
Returns (ITEM . PARENT), where PARENT is the immediate parent of
 the item found.
Signals an error if the item is not found.
Fdisable-menu-item
Make the named menu item be unselectable.
PATH is a list of strings which identify the position of the menu item in
the menu hierarchy.  ("File" "Save") means the menu item called "Save"
under the toplevel "File" menu.  ("Menu" "Foo" "Item") means the
menu item called "Item" under the "Foo" submenu of "Menu".
Fenable-menu-item
Make the named menu item be selectable.
PATH is a list of strings which identify the position of the menu item in
the menu hierarchy.  ("File" "Save") means the menu item called "Save"
under the toplevel "File" menu.  ("Menu" "Foo" "Item") means the
menu item called "Item" under the "Foo" submenu of "Menu".
Fadd-menu-item
Add a menu item to some menu, creating the menu first if necessary.
If the named item exists already, it is changed.
MENU-PATH identifies the menu under which the new menu item should be inserted.
 It is a list of strings; for example, ("File") names the top-level "File"
 menu.  ("File" "Foo") names a hypothetical submenu of "File".
ITEM-NAME is the string naming the menu item to be added.
FUNCTION is the command to invoke when this menu item is selected.
 If it is a symbol, then it is invoked with `call-interactively', in the same
 way that functions bound to keys are invoked.  If it is a list, then the
 list is simply evaluated.
ENABLED-P controls whether the item is selectable or not.
BEFORE, if provided, is the name of a menu item before which this item should
 be added, if this item is not on the menu already.  If the item is already
 present, it will not be moved.
Fdelete-menu-item
Remove the named menu item from the menu hierarchy.
PATH is a list of strings which identify the position of the menu item in
the menu hierarchy.  ("File" "Save") means the menu item called "Save"
under the toplevel "File" menu.  ("Menu" "Foo" "Item") means the
menu item called "Item" under the "Foo" submenu of "Menu".
Frelabel-menu-item
Change the string of the specified menu item.
PATH is a list of strings which identify the position of the menu item in
the menu hierarchy.  ("File" "Save") means the menu item called "Save"
under the toplevel "File" menu.  ("Menu" "Foo" "Item") means the
menu item called "Item" under the "Foo" submenu of "Menu".
NEW-NAME is the string that the menu item will be printed as from now on.
Fadd-menu
Add a menu to the menubar or one of its submenus.
If the named menu exists already, it is changed.
MENU-PATH identifies the menu under which the new menu should be inserted.
 It is a list of strings; for example, ("File") names the top-level "File"
 menu.  ("File" "Foo") names a hypothetical submenu of "File".
 If MENU-PATH is nil, then the menu will be added to the menubar itself.
MENU-NAME is the string naming the menu to be added.
MENU-ITEMS is a list of menu item descriptions.
 Each menu item should be a vector of three elements:
   - a string, the name of the menu item;
   - a symbol naming a command, or a form to evaluate;
   - and t or nil, whether this item is selectable.
BEFORE, if provided, is the name of a menu before which this menu should
 be added, if this menu is not on its parent already.  If the menu is already
 present, it will not be moved.
Fsensitize-file-and-edit-menus-hook
For use as a value of activate-menubar-hook.
This function changes the sensitivity of these File and Edit menu items:

  Cut    sensitive only when emacs owns the primary X Selection.
  Copy   sensitive only when emacs owns the primary X Selection.
  Clear  sensitive only when emacs owns the primary X Selection.
  Paste  sensitive only when there is an owner for the X Clipboard Selection.
  Undo   sensitive only when there is undo information.
         While in the midst of an undo, this is changed to "Undo More".

  Kill Buffer    has the name of the current buffer appended to it.
  Print Buffer   has the name of the current buffer appended to it.
  Save Buffer    has the name of the current buffer appended to it, and is
                 sensitive only when the current buffer is modified.
  Revert Buffer  has the name of the current buffer appended to it, and is
                 sensitive only when the current buffer has a file.
  Delete Screen  sensitive only when there is more than one screen.
Fformat-buffers-menu-line
Returns a string to represent the given buffer in the Buffer menu.
nil means the buffer shouldn't be listed.  You can redefine this.
Vbuffers-menu-max-size
*Maximum number of entries which may appear on the "Buffers" menu.
If this is 10, then only the ten most-recently-selected buffers will be
shown.  If this is nil, then all buffers will be shown.  Setting this to
a large number or nil will slow down menu responsiveness.
Vcomplex-buffers-menu-p
*If true, the buffers menu will contain several commands, as submenus
of each buffer line.  If this is false, then there will be only one command:
select that buffer.
Vbuffers-menu-switch-to-buffer-function
*The function to call to select a buffer from the buffers menu.
`switch-to-buffer' is a good choice, as is `pop-to-buffer'.
Fbuild-buffers-menu-hook
For use as a value of activate-menubar-hook.
This function changes the contents of the "Buffers" menu to correspond
to the current set of buffers.  Only the most-recently-used few buffers
will be listed on the menu, for efficiency reasons.  You can control how
many buffers will be shown by setting `buffers-menu-max-size'.
You can control the text of the menu items by redefining the function
`format-buffers-menu-line'.
Fyes-or-no-p-dialog-box
Ask user a "y or n" question with a popup dialog box.
Returns t if answer is "yes".
Takes one argument, which is the string to display to ask the question.
Fyes-or-no-p-maybe-dialog-box
Ask user a yes-or-no question.  Return t if answer is yes.
The question is asked with a dialog box or the minibuffer, as appropriate.
Takes one argument, which is the string to display to ask the question.
It should end in a space; `yes-or-no-p' adds `(yes or no) ' to it.
The user must confirm the answer with RET,
and can edit it until it as been confirmed.
Fy-or-n-p-maybe-dialog-box
Ask user a "y or n" question.  Return t if answer is "y".
Takes one argument, which is the string to display to ask the question.
The question is asked with a dialog box or the minibuffer, as appropriate.
It should end in a space; `y-or-n-p' adds `(y or n) ' to it.
No confirmation of the answer is requested; a single character is enough.
Also accepts Space to mean yes, or Delete to mean no.
Vglobal-popup-menu
The global popup menu.  This is present in all modes.
See the function `popup-menu' for a description of menu syntax.
Vmode-popup-menu
The mode-specific popup menu.  Automatically buffer local.
This is appended to the default items in `global-popup-menu'.
See the function `popup-menu' for a description of menu syntax.
Vactivate-popup-menu-hook
Function or functions run before a mode-specific popup menu is made visible.
These functions are called with no arguments, and should interrogate and
modify the value of `global-popup-menu' or `mode-popup-menu' as desired.
Note: this hook is only run if you use `popup-mode-menu' for activating the
global and mode-specific commands; if you have your own binding for button3,
this hook won't be run.
Fpopup-mode-menu
Pop up a menu of global and mode-specific commands.
The menu is computed by combining `global-popup-menu' and `mode-popup-menu'.
Fmouse-select
Select Emacs window the mouse is on.
Fmouse-delete-window
Delete the Emacs window the mouse is on.
Fmouse-keep-one-window
Select Emacs window mouse is on, then kill all other Emacs windows.
Fmouse-select-and-split
Select Emacs window mouse is on, then split it vertically in half.
Fmouse-set-point
Select Emacs window mouse is on, and move point to mouse position.
Fmouse-line-length
Print the length of the line indicated by the pointer.
Fmouse-set-mark
Select Emacs window mouse is on, and set mark at mouse position.
Display cursor at that position for a second.
Fmouse-scroll
Scroll point to the mouse position.
Fmouse-del-char
Delete the char pointed to by the mouse.
Fmouse-kill-line
Kill the line pointed to by the mouse.
Fnarrow-window-to-region
Narrow window to region between point and last mark
Fmouse-window-to-region
Narrow window to region between cursor and mouse pointer.
Fmouse-ignore
Don't do anything.
Vmouse-track-click-hook
Function or functions which are called when the user clicks the mouse.
`Clicking' means pressing and releasing the mouse without moving.  This
hook is local to every buffer and is invoked by `mouse-track'; thus, it
will not be called for any buttons with a different binding.  The functions
will be called with one argument, the button-release event.
Fmouse-track
Make a selection with the mouse.  This should be bound to a mouse button.
If you click-and-drag, the selection will be set to the region between the
point of the initial click and the point at which you release the button.
These positions need not be ordered.

If you click-and-release without moving the mouse, then the point is moved,
the functions (if any) in `mouse-track-click-hook' will be invoked, and
the selection is disowned (there will be no selection owner.)  The mark
will be set to the previous position of point. (Second parameter NOCLICK
non-nil causes `mouse-track-click-hook' to be ignored.)

If you double-click, the selection will extend by symbols instead of by
characters.  If you triple-click, the selection will extend by lines.

If you drag the mouse off the top or bottom of the window, you can select
pieces of text which are larger than the visible part of the buffer; the
buffer will scroll as necessary.

The selected text becomes the current X Selection, and is also copied to the
top of the kill ring.  The point will be left at the position at which you
released the button, and the mark will be left at the initial click position.

See also the `mouse-track-adjust' command, on \[mouse-track-adjust].
Fmouse-track-no-click
Like `mouse-track' but ignores any actions in `mouse-track-click-hook'.
Fmouse-track-adjust
Extend the existing selection.  This should be bound to a mouse button.
The selection will be enlarged or shrunk so that the point of the mouse
click is one of its endpoints.  This is only really meaningful after the
`mouse-track' command (\[mouse-track]) has been executed.
Fmouse-track-insert
Make a selection with the mouse and insert it at point.
This is exactly the same as the `mouse-track' command on \[mouse-track],
except that point is not moved; the selected text is immediately inserted
after being selected; and the selection is immediately disowned afterwards.
Fmouse-track-delete-and-insert
Make a selection with the mouse and insert it at point.
This is exactly the same as the `mouse-track' command on \[mouse-track],
except that point is not moved; the selected text is immediately inserted
after being selected; and the text of the selection is deleted.
Vdrag-modeline-event-lag
*The amount of time to wait (in msecs) between drag modeline events
before updating the display. If this value is too small, dragging will
be choppy because redisplay cannot keep up. If it is too large, dragging
will be choppy because of the explicit redisplay delay specified.
Fmouse-drag-modeline
Resize the window by dragging the modeline.
This should be bound to a mouse button in `mode-line-map'.
Vmode-motion-hook
Function or functions which are called whenever the mouse moves.
You should normally use this rather than `mouse-motion-handler', which
does some additional window-system-dependent things.  This hook is local
to every buffer, and should normally be set up by major-modes which want
to use special highlighting.  Every time the mouse moves over a window,
the mode-motion-hook of the buffer of that window is run.
Fmode-motion-highlight-line
For use as the value of `mode-motion-hook' -- highlight line under mouse.
Fmode-motion-highlight-word
For use as the value of `mode-motion-hook' -- highlight word under mouse.
Fmode-motion-highlight-symbol
For use as the value of `mode-motion-hook' -- highlight symbol under mouse.
Fmode-motion-highlight-sexp
For use as the value of `mode-motion-hook' -- highlight form under mouse.
Fminibuf-select-highlighted-completion
Select the highlighted text under the mouse as a minibuffer response.
When the minibuffer is being used to prompt the user for a completion,
any valid completions which are visible on the screen will highlight
when the mouse moves over them.  Clicking \<minibuffer-local-map>\[minibuf-select-highlighted-completion] will select the
highlighted completion under the mouse.

If the mouse is clicked while while not over a highlighted completion,
then the global binding of \[minibuf-select-highlighted-completion] will be executed instead.  In this
way you can get at the normal global behavior of \[minibuf-select-highlighted-completion] as well as
the special minibuffer behavior.
Fminibuf-maybe-select-highlighted-completion
Like minibuf-select-highlighted-completion but does nothing if there is
no completion (as opposed to executing the global binding).  Useful as the
value of `mouse-track-click-hook'.
Ffile-type-internal
Convert a user-specified file-type code into internal representation.
'text or "text" (case-insignificant) or nil is converted to nil; 'binary
or "binary" (case-insignificant) or t is converted to t; anything else
causes an error.
Fset-file-type
Under MS-DOS, set the file type of BUFFER.
The file type specifies the translations to be performed when the file
is read in or written out.

If CODE is 'text or "text" or nil, then the following translations are
performed:

-- the end-of-line sequence ^M^J is converted to ^J (Emacs' "new-line"
   character) when the file is read in
-- the character ^J is converted to ^M^J when the file is written out
-- No characters following a ^Z character are read in
-- A ^Z character is appended to the end of the file when written out

This follows the standard semantics of MS-DOS text files.

If CODE is 'binary or "binary" or t, no translations are performed.

The file type of a file is normally set automatically when the file is
first visited.

BUFFER defaults to the current buffer if not specified.
Fset-default-file-type
Set the default file type to CODE.
This is the value of `file-type' for buffers that don't override it.
See `set-file-type' for a description of the meaning of CODE.
Vfile-name-file-type-alist
Alist associating regular expressions with file type values (nil or t).
This is used to determine a file's file type when visiting the file,
unless `auto-compute-file-type-p' is nil.  Each expression is applied in
turn and the first matching one is used.  If no matching expression is
found or if `auto-compute-file-type-p' is non-nil, the value of
`default-file-type' is used.
Ffind-file-type-from-file-name
Determine a file's file-type from its name.
Ignores the value of `auto-compute-file-type-p'.  See
`file-name-file-type-alist' for more information.
Fdefine-file-name-file-type
Add a new expression to `file-name-file-type-alist'.
Files matching FILENAME (a regular expression) will have their
file type set to CODE.  See `file-name-file-type-alist' for more
information.
Ffind-file-binary
Edit file FILENAME in binary mode.
Switch to a buffer visiting file FILENAME, creating one if none
already exists.  Treat the file as binary regardless of its extension.
Ffind-file-text
Edit file FILENAME in text mode.
Switch to a buffer visiting file FILENAME, creating one if none
already exists.  Treat the file as text regardless of its extension.
Fconvert-mac-file
Convert the Macintosh file in the current buffer into text format.
Macintosh files use ^M to mark the end of a line.
Funix-to-dos-file-name
Convert filename NAME into DOS format.
This involves converting slashes to backslashes.
Fdos-to-unix-file-name
Convert DOS filename NAME into Unix format.
This involves converting backslashes into slashes.
Vmsdos-shells
*List of shells that use `/c' instead of `-c' and a backslashed command.
Fdisk-free-space
Return a list of free space information of current drive.
List elements are:
 0. Number of unused clusters.
 1. Number of bytes per sector.
 2. Number of sectors per cluster.
Fdisk-total-space
Return a list of free space information of current drive.
List elements are:
 0. Number of total clusters.
 1. Number of bytes per sector.
 2. Number of sectors per cluster.
Vlisp-mode-syntax-table

Vemacs-lisp-mode-syntax-table

Vlisp-mode-abbrev-table

Vshared-lisp-mode-map
Keymap for commands shared by all sorts of Lisp modes.
Vemacs-lisp-mode-map
Keymap for Emacs Lisp mode.
All commands in shared-lisp-mode-map are inherited by this map.
Femacs-lisp-mode
Major mode for editing Lisp code to run in Emacs.
Commands:
Delete converts tabs to spaces as it moves back.
Blank lines separate paragraphs.  Semicolons start comments.
\{emacs-lisp-mode-map}
Entry to this mode calls the value of emacs-lisp-mode-hook
if that value is non-nil.
Vlisp-mode-map
Keymap for ordinary Lisp mode.
All commands in shared-lisp-mode-map are inherited by this map.
Flisp-mode
Major mode for editing Lisp code for Lisps other than GNU Emacs Lisp.
Commands:
Delete converts tabs to spaces as it moves back.
Blank lines separate paragraphs.  Semicolons start comments.
\{lisp-mode-map}
Note that `run-lisp' may be used either to start an inferior Lisp job
or to switch back to an existing one.

Entry to this mode calls the value of lisp-mode-hook
if that value is non-nil.
Flisp-send-defun
Send the current defun to the Lisp process made by M-x run-lisp.
Vlisp-interaction-mode-map
Keymap for Lisp Interaction moe.
All commands in shared-lisp-mode-map are inherited by this map.
Flisp-interaction-mode
Major mode for typing and evaluating Lisp forms.
Like Lisp mode except that \[eval-print-last-sexp] evals the Lisp expression
before point, and prints its value into the buffer, advancing point.

Commands:
Delete converts tabs to spaces as it moves back.
Paragraphs are separated only by blank lines.  Semicolons start comments.
\{lisp-interaction-mode-map}
Entry to this mode calls the value of lisp-interaction-mode-hook
if that value is non-nil.
Feval-print-last-sexp
Evaluate sexp before point; print value into current buffer.
Feval-last-sexp
Evaluate sexp before point; print value in minibuffer.
With argument, print output into current buffer.
Feval-defun
Evaluate defun that point is in or before.
Print value in minibuffer.
With argument, insert value in current buffer after the defun.
Vlisp-indent-offset

Vlisp-indent-function

Flisp-indent-line
Indent current line as Lisp code.
With argument, indent any additional lines of the same expression
rigidly along with this one.
Fcalculate-lisp-indent
Return appropriate indentation for current line as Lisp code.
In usual case returns an integer: the column to indent to.
Can instead return a list, whose car is the column to indent to.
This means that following lines at the same level of indentation
should not necessarily be indented the same way.
The second element of the list is the buffer position
of the start of the containing expression.
Vlisp-body-indent

Findent-sexp
Indent each line of the list starting just after point.
If optional arg ENDPOS is given, indent each line, stopping when
ENDPOS is encountered.
Findent-code-rigidly
Indent all lines of code, starting in the region, sideways by ARG columns.
Does not affect lines starting inside comments or strings,
assuming that the start of the region is not inside them.
Called from a program, takes args START, END, COLUMNS and NOCHANGE-REGEXP.
The last is a regexp which, if matched at the beginning of a line,
means don't indent that line.
Vtext-mode-syntax-table
Syntax table used while in text mode.
Vtext-mode-abbrev-table
Abbrev table used while in text mode.
Vtext-mode-map
Keymap for Text mode.
Many other modes, such as Mail mode, Outline mode and Indented Text mode,
inherit all the commands defined in this map.
Ftext-mode
Major mode for editing text intended for humans to read.  Special commands:\{text-mode-map}
Turning on text-mode calls the value of the variable `text-mode-hook',
if that value is non-nil.
Vindented-text-mode-map
Keymap for Indented Text mode.
All the commands defined in Text mode are inherited unless overridden.
Findented-text-mode
Major mode for editing indented text intended for humans to read.\{indented-text-mode-map}
Turning on indented-text-mode calls the value of the variable `text-mode-hook',
if that value is non-nil.
Fchange-log-mode
Major mode for editing ChangeLog files.  See M-x add-change-log-entry.
Almost the same as Indented Text mode, but prevents numeric backups
and sets `left-margin' to 8 and `fill-column' to 74.
Fcenter-paragraph
Center each nonblank line in the paragraph at or after point.
See center-line for more info.
Fcenter-region
Center each nonblank line starting in the region.
See center-line for more info.
Fcenter-line
Center the line point is on, within the width specified by `fill-column'.
This means adjusting the indentation so that it equals
the distance between the end of the text and `fill-column'.
Vc-mode-abbrev-table
Abbrev table in use in C-mode buffers.
Vc-mode-map
Keymap used in C mode.
Fc-macro-expand
Display the result of expanding all C macros occurring in the region.
The expansion is entirely correct because it uses the C preprocessor.
Vc-mode-syntax-table
Syntax table in use in C-mode buffers.
Vc-indent-level
*Indentation of C statements with respect to containing block.
Vc-brace-imaginary-offset
*Imagined indentation of a C open brace that actually follows a statement.
Vc-brace-offset
*Extra indentation for braces, compared with other text in same context.
Vc-argdecl-indent
*Indentation level of declarations of C function arguments.
Vc-label-offset
*Offset of C label lines and case statements relative to usual indentation.
Vc-continued-statement-offset
*Extra indent for lines not starting new statements.
Vc-continued-brace-offset
*Extra indent for substatements that start with open-braces.
This is in addition to c-continued-statement-offset.
Vc-auto-newline
*Non-nil means automatically newline before and after braces,
and after colons and semicolons, inserted in C code.
If you do not want a leading newline before braces then use:
  (define-key c-mode-map "{" 'electric-c-semi)
Vc-tab-always-indent
*Non-nil means TAB in C mode should always reindent the current line,
regardless of where in the line point is when the TAB command is used.
Fc-mode
Major mode for editing C code.
Expression and list commands understand all C brackets.
Tab indents for C code.
Comments are delimited with /* ... */.
Paragraphs are separated by blank lines only.
Delete converts tabs to spaces as it moves back.
\{c-mode-map}
Variables controlling indentation style:
 c-tab-always-indent
    Non-nil means TAB in C mode should always reindent the current line,
    regardless of where in the line point is when the TAB command is used.
 c-auto-newline
    Non-nil means automatically newline before and after braces,
    and after colons and semicolons, inserted in C code.
 c-indent-level
    Indentation of C statements within surrounding block.
    The surrounding block's indentation is the indentation
    of the line on which the open-brace appears.
 c-continued-statement-offset
    Extra indentation given to a substatement, such as the
    then-clause of an if or body of a while.
 c-continued-brace-offset
    Extra indentation given to a brace that starts a substatement.
    This is in addition to c-continued-statement-offset.
 c-brace-offset
    Extra indentation for line if it starts with an open brace.
 c-brace-imaginary-offset
    An open brace following other text is treated as if it were
    this far to the right of the start of its line.
 c-argdecl-indent
    Indentation level of declarations of C function arguments.
 c-label-offset
    Extra indentation for line that is a label, or case or default.

Settings for K&R and BSD indentation styles are
  c-indent-level                5    8
  c-continued-statement-offset  5    8
  c-brace-offset               -5   -8
  c-argdecl-indent              0    8
  c-label-offset               -5   -8

Turning on C mode calls the value of the variable c-mode-hook with no args,
if that value is non-nil.
Fc-fill-paragraph
Like \[fill-paragraph] but handle C comments.
If point is inside a comment, the current paragraph of the comment
is filled, preserving the comment indentation or line-starting decorations.
Felectric-c-brace
Insert character and correct line's indentation.
Felectric-c-sharp-sign
Insert character and correct line's indentation.
Felectric-c-semi
Insert character and correct line's indentation.
Felectric-c-terminator
Insert character and correct line's indentation.
Fc-indent-command
Indent current line as C code, or in some cases insert a tab character.
If c-tab-always-indent is non-nil (the default), always indent current line.
Otherwise, indent the current line only if point is at the left margin
or in the line's indentation; otherwise insert a tab.

A numeric argument, regardless of its value,
means indent rigidly all the lines of the expression starting after point
so that this line becomes properly indented.
The relative indentation among the lines of the expression are preserved.
Fc-indent-line
Indent current line as C code.
Return the amount the indentation changed by.
Fcalculate-c-indent
Return appropriate indentation for current line as C code.
In usual case returns an integer: the column to indent to.
Returns nil if line starts inside a string, t if in a comment.
Fcalculate-c-indent-within-comment
Return the indentation amount for line inside a block comment.
Non-nil arg AFTER-STAR means, if lines in the comment have a leading star,
return the indentation of the text that would follow this star.
Fc-backward-to-start-of-if
Move to the start of the last ``unbalanced'' if.
Fc-backward-to-start-of-do
If point follows a `do' statement, move to beginning of it and return `t'.
Otherwise return `nil' and don't move point.
Fmark-c-function
Put mark at end of C function, point at beginning.
Findent-c-exp
Indent each line of the C grouping following point.
If optional arg ENDPOS is given, indent each line, stopping when
ENDPOS is encountered.
Fabbrev-mode
Toggle abbrev mode.
With arg, turn abbrev mode on iff arg is positive.
In abbrev mode, inserting an abbreviation causes it to expand
and be replaced by its expansion.
Vedit-abbrevs-map
Keymap used in edit-abbrevs.
Fkill-all-abbrevs
Undefine all defined abbrevs.
Finsert-abbrevs
Insert after point a description of all defined abbrevs.
Mark is set after the inserted text.
Flist-abbrevs
Display a list of all defined abbrevs.
Fedit-abbrevs-mode
Major mode for editing the list of abbrev definitions.
\{edit-abbrevs-map}
Fedit-abbrevs
Alter abbrev definitions by editing a list of them.
Selects a buffer containing a list of abbrev definitions.
You can edit them and type C-c C-c to redefine abbrevs
according to your editing.
Buffer contains a header line for each abbrev table,
 which is the abbrev table name in parentheses.
This is followed by one line per abbrev in that table:
NAME   USECOUNT   EXPANSION   HOOK
where NAME and EXPANSION are strings with quotes,
USECOUNT is an integer, and HOOK is any valid function
or may be omitted (it is usually omitted).
Fedit-abbrevs-redefine
Redefine abbrevs according to current buffer contents.
Fdefine-abbrevs
Define abbrevs according to current visible buffer contents.
See documentation of edit-abbrevs for info on the format of the
text you must have in the buffer.
With argument, eliminate all abbrev definitions except
the ones defined from the buffer now.
Fread-abbrev-file
Read abbrev definitions from file written with write-abbrev-file.
Takes file name as argument.
Optional second argument non-nil means don't print anything.
Fquietly-read-abbrev-file
Read abbrev definitions from file written with write-abbrev-file.
Takes file name as argument.  Does not print anything.
Fwrite-abbrev-file
Write all abbrev definitions to file of Lisp code.
The file can be loaded to define the same abbrevs.
Fadd-mode-abbrev
Define mode-specific abbrev for last word(s) before point.
Argument is how many words before point form the expansion;
or zero means the region is the expansion.
A negative argument means to undefine the specified abbrev.
Reads the abbreviation in the minibuffer.

Don't use this function in a Lisp program; use define-abbrev instead.
Fadd-global-abbrev
Define global (all modes) abbrev for last word(s) before point.
Argument is how many words before point form the expansion;
or zero means the region is the expansion.
A negative argument means to undefine the specified abbrev.
Reads the abbreviation in the minibuffer.

Don't use this function in a Lisp program; use define-abbrev instead.
Finverse-add-mode-abbrev
Define last word before point as a mode-specific abbrev.
With argument N, defines the Nth word before point.
Reads the expansion in the minibuffer.
Expands the abbreviation after defining it.
Finverse-add-global-abbrev
Define last word before point as a global (mode-independent) abbrev.
With argument N, defines the Nth word before point.
Reads the expansion in the minibuffer.
Expands the abbreviation after defining it.
Fabbrev-prefix-mark
Mark current point as the beginning of an abbrev.
Abbrev to be expanded starts here rather than at
beginning of word.  This way, you can expand an abbrev
with a prefix: insert the prefix, use this command,
then insert the abbrev.
Fexpand-region-abbrevs
For abbrev occurrence in the region, offer to expand it.
The user is asked to type y or n for each occurrence.
A numeric argument means don't query; expand all abbrevs.
Calling from a program, arguments are START END &optional NOQUERY.
VBuffer-menu-mode-map

FBuffer-menu-mode
Major mode for editing a list of buffers.
Each line describes one of the buffers in Emacs.
Letters do not insert themselves; instead, they are commands.
m -- mark buffer to be displayed.
q -- select buffer of line point is on.
  Also show buffers marked with m in other windows.
1 -- select that buffer in full-screen window.
2 -- select that buffer in one window,
  together with buffer selected before this one in another window.
f -- select that buffer in place of the buffer menu buffer.
o -- select that buffer in another window,
  so the buffer menu buffer remains visible in its window.
t -- visit-tags-table this buffer.
~ -- clear modified-flag on that buffer.
s -- mark that buffer to be saved, and move down.
d or k -- mark that buffer to be deleted, and move down.
C-d -- mark that buffer to be deleted, and move up.
x -- delete or save marked buffers.
u -- remove all kinds of marks from current line.
Delete -- back up a line and remove marks.

Precisely,\{Buffer-menu-mode-map}
FBuffer-menu-buffer
Return buffer described by this line of buffer menu.
Vlist-buffers-identification
String used to identify this buffer, or a function of one argument
to generate such a string.  This variable is always buffer-local.
Flist-buffers
Display a list of names of existing buffers.
Inserts it in buffer *Buffer List* and displays that.
Note that buffers with names starting with spaces are omitted.
Non-null optional arg FILES-ONLY means mention only file buffers.

The M column contains a * for buffers that are modified.
The R column contains a % for buffers that are read-only.
Fbuffer-menu
Make a menu of buffers so you can save, delete or select them.
With argument, show only buffers that are visiting files.
Type ? after invocation to get help on commands available.
Type q immediately to make the buffer menu go away.
FBuffer-menu-mark
Mark buffer on this line for being displayed by \[Buffer-menu-select] command.
FBuffer-menu-unmark
Cancel all requested operations on buffer on this line.
FBuffer-menu-backup-unmark
Move up and cancel all requested operations on buffer on line above.
FBuffer-menu-delete
Mark buffer on this line to be deleted by \[Buffer-menu-execute] command.
FBuffer-menu-delete-backwards
Mark buffer on this line to be deleted by \[Buffer-menu-execute] command
and then move up one line
FBuffer-menu-save
Mark buffer on this line to be saved by \[Buffer-menu-execute] command.
FBuffer-menu-not-modified
Mark buffer on this line as unmodified (no changes to save).
FBuffer-menu-execute
Save and/or delete buffers marked with \[Buffer-menu-save] or \[Buffer-menu-delete] commands.
FBuffer-menu-select
Select this line's buffer; also display buffers marked with ">".
You can mark buffers with the \[Buffer-menu-mark] command.
FBuffer-menu-visit-tags-table
Visit the tags table in the buffer on this line.  See `visit-tags-table'.
FBuffer-menu-1-window
Select this line's buffer, alone, in full screen.
FBuffer-menu-this-window
Select this line's buffer in this window.
FBuffer-menu-other-window
Select this line's buffer in other window, leaving buffer menu visible.
FBuffer-menu-2-window
Select this line's buffer, with previous buffer in second window.
Fproclaim-inline
Cause the named functions to be open-coded when called from compiled code.
They will only be compiled open-coded when byte-compile-optimize is true.
Fproclaim-notinline
Cause the named functions to no longer be open-coded.
Fdefsubst
Same syntax as defun, but the defined function will always be open-coded,
so long as byte-compile-optimize is true.
Fmake-obsolete
Make the byte-compiler warn that FUNCTION is obsolete,
and NEW should be used instead.  If NEW is a string, then that is the
`use instead' message.
Fmake-obsolete-variable
Make the byte-compiler warn that VARIABLE is obsolete,
and NEW should be used instead.  If NEW is a string, then that is the
`use instead' message.
Fdont-compile
Like progn, but the body will always run interpreted (not compiled).
If you think you need this, you're probably making a mistake somewhere.
Feval-when-compile
Like progn, but evaluates the body at compile-time.  The result of the
body appears to the compiler as a quoted constant.
Feval-and-compile
Like progn, but evaluates the body at compile-time as well as at load-time.
Fbyte-compiler-options
Set some compilation-parameters for this file.  This will affect only the
file in which it appears; this does nothing when evaluated, and when loaded
from a .el file.

Each argument to this macro must be a list of a key and a value.

  Keys:          Values:        Corresponding variable:

  verbose      t, nil        byte-compile-verbose
  optimize      t, nil, source, byte    byte-compile-optimize
  warnings      list of warnings    byte-compile-warnings
              Legal elements: (callargs redefine free-vars unresolved)
  file-format      emacs18, emacs19    byte-compile-emacs18-compatibility
  new-bytecodes      t, nil        byte-compile-generate-emacs19-bytecodes

For example, this might appear at the top of a source file:

    (byte-compiler-options
      (optimize t)
      (warnings (- free-vars))        ; Don't warn about free variables
      (file-format emacs19))
Fx-make-font-bold
Given an X font specification, this attempts to make a `bold' version
of it.  If it fails, it returns nil.
Fx-make-font-demibold
Given an X font specification, this attempts to make a `demibold' version
of it.  If it fails, it returns nil.
Fx-make-font-unbold
Given an X font specification, this attempts to make a non-bold version
of it.  If it fails, it returns nil.
Fx-make-font-italic
Given an X font specification, this attempts to make an `italic' version
of it.  If it fails, it returns nil.
Fx-make-font-oblique
Given an X font specification, this attempts to make an `italic' version
of it.  If it fails, it returns nil.
Fx-make-font-unitalic
Given an X font specification, this attempts to make a non-italic version
of it.  If it fails, it returns nil.
Fx-font-size
Returns the nominal size of the given font.
This is done by parsing its name, so it's likely to lose.
X fonts can be specified (by the user) in either pixels or 10ths of points,
 and this returns the first one it finds, so you have to decide which units
 the returned value is measured in yourself...
Fmake-face-bold
Make the font of the given face be bold, if possible.
Returns nil on failure.
Fmake-face-italic
Make the font of the given face be italic, if possible.
Returns nil on failure.
Fmake-face-bold-italic
Make the font of the given face be bold and italic, if possible.
Returns nil on failure.
Fmake-face-unbold
Make the font of the given face be non-bold, if possible.
Returns nil on failure.
Fmake-face-unitalic
Make the font of the given face be non-italic, if possible.
Returns nil on failure.
Fx-initialize-other-random-faces
Initializes the colors and fonts of the bold, italic, bold-italic,
primary-selection, secondary-selection, and isearch faces when each
screen is created.  If you want to add code to do stuff like this, use
the create-screen-hook.
Fx-mouse-kill
Kill the text between the point and mouse and copy it to the clipboard and
to the cut buffer
Fx-insert-selection
Insert the current selection into buffer at point.
Fx-set-point-and-insert-selection
Sets point where clicked and insert the primary selection or the cut buffer
Fmouse-track-and-copy-to-cutbuffer
Makes a selection like `mouse-track', but also copies it to the cutbuffer.
Vx-pointer-shape
*The shape of the mouse-pointer when over text.

This string may be any of the standard cursor names from appendix B
of the Xlib manual (also known as the file <X11/cursorfont.h>) minus
the XC_ prefix, or it may be a font name and glyph index of the form
"FONT fontname index [[font] index]", or it may be the name of a
bitmap file acceptable to XmuLocateBitmapFile().  If it is a bitmap
file, and if a bitmap file whose name is the name of the cursor with
"msk" exists, then it is used as the mask.  For example, a pair of
files may be named "cursor.xbm" and "cursor.xbmmsk".
Vx-nontext-pointer-shape
*The shape of the mouse-pointer when over a buffer, but not over text.
If this is nil, then `x-pointer-shape' is used.
Vx-mode-pointer-shape
*The shape of the mouse-pointer when over the modeline.
If this is nil, then either `x-nontext-pointer-shape' or `x-pointer-shape'
will be used.
Vx-selection-pointer-shape
*The shape of the mouse-pointer when over a selectable text region.
Vx-pointer-foreground-color
*The foreground color of the mouse pointer.
Vx-pointer-background-color
*The background color of the mouse pointer.
Fx-initialize-pointer-shape
Initializes the mouse-pointers of the given screen from the resource
database.
Fx-get-selection
Return text selected from some X window.
Fx-get-secondary-selection
Return text selected from some X window.
Fx-get-clipboard
Return text pasted to the clipboard.
Vprimary-selection-extent
The extent of the primary selection; don't use this.
Vsecondary-selection-extent
The extent of the secondary selection; don't use this.
Fx-own-selection
Make a primary X Selection of the given argument.
The argument may be a string, a cons of two markers, or an extent.
In the latter cases the selection is considered to be the text
between the markers, or the between extents endpoints.
Fx-own-secondary-selection
Make a secondary X Selection of the given argument.  The argument may be a
string or a cons of two markers (in which case the selection is considered to
be the text between those markers.)
Fx-own-clipboard
Paste the given string to the X Clipboard.
Fx-disown-selection
Assuming we own the selection, disown it.  With an argument, discard the
secondary selection instead of the primary selection.
Fx-dehilight-selection
for use as a value of x-lost-selection-hooks.
Fx-notice-selection-requests
for possible use as the value of x-sent-selection-hooks.
Fx-notice-selection-failures
for possible use as the value of x-sent-selection-hooks.
Fx-get-cutbuffer
Returns the value of one of the 8 X server cut buffers.  Optional arg
WHICH-ONE should be a number from 0 to 7, defaulting to 0.
Cut buffers are considered obsolete; you should use selections instead.
This function does nothing if support for cut buffers was not compiled
into Emacs.
Fx-store-cutbuffer
Store the given string into the X server's primary cut buffer.
The previous value of the primary cut buffer is rotated to the secondary
cut buffer, and the second to the third, and so on (there are 8 buffers.)
Cut buffers are considered obsolete; you should use selections instead.
This function does nothing if support for cut buffers was not compiled
into Emacs.
Fx-supports-cutbuffers-p
Returns whether support for cut buffers was compiled into Emacs.
Cut buffers are considered obsolete; you should use selections instead.
Fx-kill-primary-selection
If there is a selection, delete the text it covers, and copy it to
both the kill ring and the Clipboard.
Fx-delete-primary-selection
If there is a selection, delete the text it covers *without* copying it to
the kill ring or the Clipboard.
Fx-copy-primary-selection
If there is a selection, copy it to both the kill ring and the Clipboard.
Fx-yank-clipboard-selection
If someone owns a Clipboard selection, insert it at point.